数据结构树

注意
深度是从上到下数的，而高度是从下往上数，树的高度和深度是相等的

深度优先搜索算法

let tree = {
  val: "a",
  children: [
    {
      val: "b",
      children: [
        { val: "d", children: [] },
        { val: "e", children: [] },
      ],
    },
    {
      val: "c",
      children: [{ val: "f", children: [] }],
    },
  ],
};
function DFS(node) {
  console.log(node.val);
  node.children.forEach(DFS);
}
DFS(tree);

广度优先搜索算法

function BFS(node) {
  let stack = [node];
  while (stack.length) {
    let item = stack.shift();
    console.log(item.val);
    item.children.forEach((u) => {
      stack.push(u);
    });
  }
}
BFS(tree);

数据量大递归会耗费性能

let tree = {
  val: 1,
  left: {
    val: 2,
    left: { val: 4, left: null, right: null },
    right: { val: 5, left: null, right: null },
  },
  right: {
    val: 3,
    left: { val: 6, left: null, right: null },
    right: { val: 7, left: null, right: null },
  },
};

二叉树前序遍历算法（根左右）

递归方法

function preorderTraversal(node) {
  let arr = [];
  function inner(item) {
    if (item) {
      //根节点
      arr.push(item.val);
      //左子树
      inner(item.left);
      //右子树
      inner(item.right);
    }
  }
  inner(node);
  return arr;
}
console.log(preorderTraversal(tree));

非递归方法

function preorderTraversal(node) {
  if (!node) return [];
  let arr = [];
  let stack = [node];
  while (stack.length) {
    let item = stack.pop();
    arr.push(item.val);

    item.right && stack.push(item.right);
    item.left && stack.push(item.left);
  }
  return arr;
}
console.log(preorderTraversal(tree));

二叉树中序遍历算法（左根右）

递归方法

function inorderTraversal(node) {
  let arr = [];
  function inner(item) {
    if (item) {
      //左子树
      inner(item.left);
      //根节点
      arr.push(item.val);
      //右子树
      inner(item.right);
    }
  }
  inner(node);
  return arr;
}
console.log(inorderTraversal(tree));

非递归方法

function inorderTraversal(node) {
  let arr = [];
  let stack = [];
  let item = node;
  while (stack.length || item) {
    while (item) {
      stack.push(item);
      item = item.left;
    }
    let obj = stack.pop();
    arr.push(obj.val);
    item = obj.right;
  }
  return arr;
}
console.log(inorderTraversal(tree));

二叉树后序遍历算法（左右根）

递归方法

function postorderTraversal(node) {
  let arr = [];
  function inner(item) {
    if (item) {
      //左子树
      inner(item.left);
      //右子树
      inner(item.right);
      //根节点
      arr.push(item.val);
    }
  }
  inner(node);
  return arr;
}
console.log(postorderTraversal(tree));

非递归方法

function postorderTraversal(node) {
  if (!node) return [];
  let arr = [];
  let stack = [node];
  while (stack.length) {
    let item = stack.pop();
    arr.unshift(item.val);
    item.left && stack.push(item.left);
    item.right && stack.push(item.right);
  }
  return arr;
}
console.log(postorderTraversal(tree));