常见数据结构生成方式

前端算法总结

1.场景，

想象一下，如果我们没有合适的数据结构去做算法，就像是一群无所适从的小朋友一堆积木没有积木，什么都做不了！初初刷力扣，发现符合的数据结构难以寻找，所以，本文总结了部分基础数据结构的创建方式。

注意：本文主要介绍链表，树，图，hash表，堆的创建方式， 数组，队列(先进后出)和栈(先进先出)，本质上和js数组无太大区别，在js使用数组方法pop(),push(),shift(),unshift()可简易实现，故此处不进行记录

常见数据结构

创建链表

// 创建函数
const data = [1,2,3,4,5,6]
const generationLinkList = (data) => {
    let root = {next:null}
    let node = root;
    for(let i=0;i<data.length;i++){
        let temp = {value:data[i],next:null}
        node.next = temp
        node = node.next
    }
    return root.next
}

const linkList = generationLinkList(data)

// 链表单独创建
function ListNode(value){
    this.value = value
    this.next = null
}

const l1 = new ListNode(1)
l1.next = new ListNode(2)
l1.next.next = new ListNode(3)
const l2 = new ListNode(1)
l2.next = new ListNode(3)
l2.next.next = new ListNode(4)

创建二叉树

1. 创建二叉树节点：定义一个 TreeNode 类，其构造函数接收一个值作为参数，并初始化 val、left 和 right 属性为 null。

// 创建函数
function TreeNode(val) {
  this.val = val;
  this.left = this.right = null;
}

2. 转换二叉树: 使用 arrayToTree 函数来将数组转换为二叉树。递归地从数组中构建二叉树节点，直到数组遍历完成。

// 广度优先构建
function arrayToTree(arr, index) {
  if (index < arr.length) {
    let val = arr[index];
    if (val === null) {
      return null;
    }

    let node = new TreeNode(val);
    node.left = arrayToTree(arr, 2 * index + 1);
    node.right = arrayToTree(arr, 2 * index + 2);

    return node;
  }
  return null;
}

3. 遍历二叉树：创建一个 traverseTree 函数，接收一个根节点作为输入，并使用递归遍历二叉树。

// 递归深度优先遍历树
function traverseTree(node) {
  if (node === null) {
    return;
  }

  console.log(node.val);
  traverseTree(node.left);
  traverseTree(node.right);
}

4. 生成测试：使用以下代码创建一个二叉树并进行遍历

// 示例用法
let arr = [1,2,3,4,5,6,null,null,7];
let root = arrayToTree(arr, 0);  // 广度构建二叉树
traverseTree(root); // 深度优先遍历树结构

创建图

1. 邻接表：使用对象的键值对来表示图的顶点和边。每个顶点作为键，对应的值是一个数组，包含与该顶点相邻的顶点。

// 举例：无向图的邻接表表示
let graph = {
  1: [2, 3],
  2: [1, 3],
  3: [1, 2, 4],
  4: [3]
};

2. 邻接矩阵：使用二维数组来表示顶点之间的关系，数组的值表示顶点之间的边的权重或是否相连。

// 举例：无向图的邻接矩阵表示
let graph = [
  [0, 1, 1, 0],
  [1, 0, 1, 0],
  [1, 1, 0, 1],
  [0, 0, 1, 0]
];

创建hash表

JavaScript 中的对象实际上就是一种哈希表，它使用键值对存储数据，具有快速的插入、删除和查找操作。

// 创建哈希表
let hashTable = {};

// 插入键值对
hashTable["key1"] = "value1";
hashTable["key2"] = "value2";

// 访问值
console.log(hashTable["key1"]); // 输出 "value1"

创建最大堆

js 中创建堆结构，可以使用数组来表示堆。堆是一种特殊的树形数据结构，满足以下两个条件：

• 堆是一个完全二叉树。
• 堆中每个节点的值都大于等于（或小于等于）其子节点的值。

创建最大堆，使用数组来表示最大堆，其中第一个元素是堆的根节点，每个节点的左子节点和右子节点分别是 2i+1 和 2i+2，其中 i 是节点在数组中的索引。最大堆中每个节点的值都大于等于其子节点的值。

// 创建最大堆
let maxHeap = [];

// 插入元素
function insertMaxHeap(val) {
  maxHeap.push(val);
  let index = maxHeap.length - 1;
  while (index > 0) {
    let parentIndex = Math.floor((index - 1) / 2);
    if (maxHeap[parentIndex] < maxHeap[index]) {
      [maxHeap[parentIndex], maxHeap[index]] = [maxHeap[index], maxHeap[parentIndex]];
      index = parentIndex;
    } else {
      break;
    }
  }
}

// 删除元素
function deleteMaxHeap() {
  if (maxHeap.length === 0) {
    return null;
  }

  let maxVal = maxHeap[0];
  maxHeap[0] = maxHeap[maxHeap.length - 1];
  maxHeap.pop();

  let index = 0;
  while (index < maxHeap.length) {
    let leftIndex = 2 * index + 1;
    let rightIndex = 2 * index + 2;
    let maxIndex = index;

    if (leftIndex < maxHeap.length && maxHeap[leftIndex] > maxHeap[maxIndex]) {
      maxIndex = leftIndex;
    }

    if (rightIndex < maxHeap.length && maxHeap[rightIndex] > maxHeap[maxIndex]) {
      maxIndex = rightIndex;
    }

    if (maxIndex !== index) {
      [maxHeap[index], maxHeap[maxIndex]] = [maxHeap[maxIndex], maxHeap[index]];
      index = maxIndex;
    } else {
      break;
    }
  }

  return maxVal;
}