数据结构

数据结构种类很多，甚至你也可以发明自己的数据结构，但是底层存储无非数组或者链表，二者的优缺点如下：

数组由于是紧凑连续存储,可以随机访问，通过索引快速找到对应元素，而且相对节约存储空间。但正因为连续存储，内存空间必须一次性分配够，所以说数组如果要扩容，需要重新分配一块更大的空间，再把数据全部复制过去，时间复杂度 O(N)；而且你如果想在数组中间进行插入和删除，每次必须搬移后面的所有数据以保持连续，时间复杂度 O(N)。

链表因为元素不连续，而是靠指针指向下一个元素的位置，所以不存在数组的扩容问题；如果知道某一元素的前驱和后驱，操作指针即可删除该元素或者插入新元素，时间复杂度 O(1)。但是正因为存储空间不连续，你无法根据一个索引算出对应元素的地址，所以不能随机访问；而且由于每个元素必须存储指向前后元素位置的指针，会消耗相对更多的储存空间。

数组的迭代和递归的遍历

// 迭代
const arr = [1, 2, 3, 4]
for (let i = 0; i < arr.length; i++) {
  console.log(arr[i])
}
// 递归
function traverse(arr, i) {
  if (!arr.length) return
  traverse(arr, i + 1)
}

链表的迭代与递归

// 链表的定义
function LinkNode(val) {
  this.val = val
  this.next = null
}
const link = new LinkNode(1)
link.next = new LinkNode(2)
// 链表的迭代
let p = link
while (p) {
  console.log(p.val)
  p = p.next
}
// 链表的迭代
function traverse(link) {
  if (!link) return
  console.log(link.val)
  traverse(link.next)
}
traverse(link)

二叉树的递归

// 二叉树的定义
function TreeNode(val) {
  this.val = val
  this.left = null
  this.right = null
}
// 二叉树的递归
const root = new TreeNode(1) // 定义一个基本的二叉树root
root.left = new TreeNode(2)
root.right = new TreeNode(3)

function traverse(root) {
  if (!root) return
  //前序
  console.log(root.val)
  traverse(root.left)
  traverse(root.right)
}

traverse(root)

多叉树的遍历

// 多叉树的定义
function TreeNode(val) {
  this.val = val
  this.children = []
}
const root = new TreeNode(1)
const root2 = new TreeNode(2)
const root3 = new TreeNode(3)
const root4 = new TreeNode(4)
root.children = [root2, root3, root4]

function traverse(root) {
  if (!root) return
  // console.log(root.val) // 前序
  for (let i = 0; i < root.children.length; i++) {
    traverse(root.children[i])
  }
  // console.log(root.val) // 后序
}
traverse(root)