算法 - 二叉树操作 - javascript版

二叉树的递归遍历方式：

前序遍历：先遍历根结点，然后左子树，再右子树
中序遍历：先遍历左子树，然后根结点，再右子树
后续遍历：先遍历左子树，然后右子树，再根结点

二叉树的非递归遍历：

深度优先遍历（主要利用栈的先进后出）
广度优先遍历（主要利用队列的先进先出）

定义TreeNode

const Node = function (value) {
  this.value = value
  this.left = null
  this.right = null
}
Node.createTree = function () {
  const root = new Node('A');
  root.left = new Node('B');
  root.right = new Node('C');
  root.left.left = new Node('D');
  root.left.left.left = new Node('G');
  root.left.left.right = new Node('H');
  root.right.left = new Node('E');
  root.right.right = new Node('F');
  root.right.left.right = new Node('I');
  return root;
}

平时要想存储一棵二叉树，可以两种方法，一种是基于指针或者引用的二叉树链式存储，也可以基于数组的顺序存储； 例如我们根据完全二叉树的模型建立自己的二叉树，空数据的地方用#表示，如下图所示我们称之为扩展二叉树，我们取其前序遍历的序列 AB#D##C##。

以上创建二叉树的方式过于笨拙, 我们可以使用字符串序列方式反推创建一个二叉树

Node.createTree = function (array) {
  if (array.length === 0) return null;
  const value = array.shift();
  if (value === '#') return null;
  const root = new Node(value);
  const left = Node.createTree(nums);
  if (left) root.left = left;
  const right = Node.createTree(nums);
  if (right) root.right = right;
  return root;
}

const treeNode = Node.createTree('AB#D##C##'.split(''));
proOrderTraverse(treeNode);

实现前中后递归遍历

// 前序遍历
function proOrderTraverse(root) {
  if (root === null) return;
  process.stdout.write(root.value + ' ');
  proOrderTraverse(root.left);
  proOrderTraverse(root.right);
}
// 中序遍历
function inOrderTraverse(root) {
  if (root === null) return;
  inOrderTraverse(root.left);
  process.stdout.write(root.value + ' ');
  inOrderTraverse(root.right)
}
// 后续遍历
function postOrderTraverse(root) {
  if (root === null) return;
  postOrderTraverse(root.left);
  postOrderTraverse(root.right);
  process.stdout.write(root.value + ' ');
}

const treeData = Node.createTree();
console.log('\n前序遍历:');
proOrderTraverse(treeData); // 前序遍历
console.log('\n中序遍历:');
inOrderTraverse(treeData); // 中序遍历
console.log('\n后续遍历:');
postOrderTraverse(treeData); // 后续遍历

实现二叉树非递归遍历

// 深度优先非递归
function depthFirstSearch(root) {
  let stack = [];
  stack.push(root);
  while (stack.length != 0) {
      let node = stack.pop();
      process.stdout.write(node.value + ' ');
      if (node.right) {
          stack.push(node.right);
      }
      if (node.left) {
          stack.push(node.left);
      }
  }
}

// 广度优先非递归
function breadthFirstSearch(root) {
  let queue = [];
  queue.push(root);
  while (queue.length != 0) {
      let node = queue.shift();
      process.stdout.write(node.value + ' ');
      if (node.left) {
          queue.push(node.left);
      }
      if (node.right) {
          queue.push(node.right);
      }
  }
}

深度优先遍历 主要是利用栈，先压右子树，再压左子树;
广度优先遍历 主要利用队列，先入左子树，再入右子树;
深度优先的遍历结果与前序遍历相同ABDGHCEIF，广度优先的遍历结果是 ABCDEFGHI