JavaScript数据结构与算法 --树的遍历和搜索（2）

12.遍历二叉搜索树

前面，我们向树中插入了很多的数据，为了能更好的看到测试结果，我们先来学习一下树的遍历。

• 注意：我们这里学习了树的遍历，针对所有的二叉树都是适用的，不仅仅二叉搜索树。

树的遍历：

• 建立二叉树
  
• 遍历一棵树是指访问的树的每个节点(也可以对每个节点进行某些操作，我们这里就是简单的打印)
• 但是树和线性结构不太一样，线性结构我们通常按照从前到后的顺序遍历。
• 应该从树的顶端还是底端开始呢？从左端还是右端呢？

二叉树的遍历常见的有三种方法

• 先序遍历 preOrderTraverse:先序遍历
• 中序遍历 inOrderTarverse:中序遍历
• 后续遍历 postOrderTraverse:后序遍历
• (还有层序遍历，使用较少，可以使用队列来完成，此处不给实现)
  实现方法

先序遍历

• 先序遍历过程为：5 2 1 0 4 3 6 8 7 9 10

  • 访问根节点
  • 先序遍历其左子树
  • 先序遍历其右子树

• 图示先序遍历过程
  

• 代码展示(递归遍历)

//封装先序遍历
    BinarySearchTree.prototype.preOrderTraversal = function (handler) {
        this.preOrderTranversalNode(this.root, handler)
    }


    BinarySearchTree.prototype.preOrderTranversalNode = function (node, handler) {
        if (node !== null) {
            // 1.打印当前经过的节点
            handler(node.key)
            // 2.遍历所有的左子树
            this.preOrderTranversalNode(node.left, handler)
            // 3.遍历所有的右子树
            this.preOrderTranversalNode(node.right, handler)
        }
    }

}
//代码测试
var bst = new BinarySearchTree();
//插入节点
bst.insert(5)
bst.insert(2)
bst.insert(6)
bst.insert(8)
bst.insert(7)
bst.insert(1)
bst.insert(0)
bst.insert(9)
bst.insert(4)
bst.insert(3)
bst.insert(10)

//测试先序遍历
function preOrderTraveral() {
    var resultString = '';
    bst.preOrderTraversal(function (key) {
        resultString += key + ' ';
    })

    return resultString;
}

console.log(preOrderTraveral());
//5 2 1 0 4 3 6 8 7 9 10 

中序遍历

• 中序遍历过程为：0 1 2 3 4 5 6 7 8 9 10
  • 中序遍历其左子树
  • 访问根节点
  • 中序遍历其右子树
• 图示中序遍历过程
  
• 代码展示(递归遍历)

// 中序遍历
BinarySearchTree.prototype.inOrderTraversal = function (handler) {
    this.inOrderTraversalNode(this.root, handler)
}

BinarySearchTree.prototype.inOrderTraversalNode = function (node, handler) {
    if (node !== null) {
        this.inOrderTraversalNode(node.left, handler)
        handler(node.key)
        this.inOrderTraversalNode(node.right, handler)
    }
}

}

//测试中序遍历
function inOrderTraversal() {
    var resultString = '';
    bst.inOrderTraversal(function (key) {
        resultString += key + ' ';
    })

    return resultString;
}



console.log(inOrderTraversal());
//0 1 2 3 4 5 6 7 8 9 10 

后序遍历

• 后序遍历过程为：0 1 3 4 2 7 10 9 8 6 5
  • 后序遍历其左子树
  • 后序遍历其右子树
  • 访问根节点
• 图示后序遍历过程
  
• 代码展示(递归遍历)

// 后序遍历
// 后续遍历
BinarySearchTree.prototype.postOrderTraversal = function (handler) {
    this.postOrderTraversalNode(this.root,handler)
}

BinarySearchTree.prototype.postOrderTraversalNode = function (node, handler) {
    if (node !== null) {
        this.postOrderTraversalNode(node.left, handler)
        this.postOrderTraversalNode(node.right, handler)
        handler(node.key)
    }
}

//测试后序遍历
function postOrderTraversal() {
    var resultString = '';
    bst.postOrderTraversal(function (key) {
        resultString += key + ' ';
    })

    return resultString;
}
console.log(postOrderTraversal());
//0 1 3 4 2 7 10 9 8 6 5 

二叉搜索树查找最小节点和最大节点

根据二叉搜索树的特点我们知道一直查找左节点当左节点为null，即为最小值

• 代码封装

 //获取最小值
    BinarySearchTree.prototype.min = function(){
    //1.获取根节点
    var node = this.root;

    // 2.依次向右查找，知道节点为null
    var key = null;
    while(node != null){
        key = node.key;
        node = node.left;
    }
    return key;
}

根据二叉搜索树的特点我们知道一直查找右节点当左节点为null，即为最小值

• 代码封装

//获取最大值
BinarySearchTree.prototype.max = function(){
    //1.获取根节点
    var node = this.root;

    // 2.依次向右查找，知道节点为null
    var key = null;
    while(node != null){
        key = node.key;
        node = node.right;
    }
    return key;
}

代码测试
console.log("------------最大值最小值--------------")
    //测试最大值，最小值
    console.log(bst.max());
    //10
    console.log(bst.min());
    //0

• 后续是 根据特定值搜索，以及二叉树节点删除（这个有点麻烦）。。
• 未完待续。。。。。。