二叉树的递归遍历方式:
前序遍历:先遍历根结点,然后左子树,再右子树
中序遍历:先遍历左子树,然后根结点,再右子树
后续遍历:先遍历左子树,然后右子树,再根结点
二叉树的非递归遍历:
深度优先遍历(主要利用栈的先进后出)
广度优先遍历(主要利用队列的先进先出)
定义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