javascript 二叉树(Trees)算法与说明

二叉树的介绍

树是一个非顺序数据结构，它对于存储需要快速查找的数据非常有用。

现实例子就是公司的组织架构，总裁为树的最顶端叫根节点，各部门按照领导人区分为子树。

---

二叉树术语概念

整个二叉树结构中，每个点叫作节点，每个节点都有父节点，而最上面的为根节点，根节点是没有父节点的。
节点另外一个属性为深度，是根据父节点有多少个来算的。
由根节点向下分的2个节点为子树，子树下面节点也是子树。

如图：
1.11为根节点
2.根节点有2个子节点7，15
3.7，15又为子树。
4.5，9，13，20又为7，15的子树。
5.最下排的节点深度为3，向上走递减。

---

二叉树和二叉树搜索

二叉树最多2个节点，一个是左侧子节点，一个是右侧子节点。这些定义有助于我们写出更高效的向树中插入、查找和删除节点的算法。
二叉树搜索树（BST）是二叉树的一种，但是它只允许你在左侧节点存储（比父节点）小的值，在右侧节点存储（比父节点）大（或者等于）的值。

例子—插入一个节点

如根据下图，现在已经有一个二叉树。我们需要添加一个6，是怎样的？



首先会检测二叉树是否为空？
第二检测根节点(key[6] < root[11]为真),然后继续检测（node.left不是null），到达node.left[7]节点。
第三检测(key[6] < key[7]为真),然后继续检测（node.left不是null），到达node.left[5]节点。
最后检测(key[6] < key[5]为真),然后继续检测（node.right不是null），为空添加在key[5]右节点添加key[6]。

例子—移除一个节点

现在我们要移除一个节点5。

首先会检测二叉树是否为空？
第二检测根节点(key[5] = root[11]为真),然后检查（key[5] < root[11]）然后继续检测（node.left不是null），到达node.left[7]节点。
第三检测根节点(key[5] = key[7]为真),然后检查(key[5] < key[7]为真),然后继续检测（node.left不是null），到达node.left[5]节点。
第四检测(key[5] = key[5]为真),然后删除 key[5]节点。
最后(key[5] )子节点，key[3]的父节点改成原来key[5]的父节点key[7]。

---

二叉树的遍历

二叉树的遍历有三种方式：中序遍历、先序遍历和后序遍历。

中序遍历

中序遍历是一种以上行顺序访问BST所有节点的遍历方式，也就是以从最小到最大的顺序访问所有节点。可以应用于树的排序操作。
如图：

访问顺序：3，5，6，7，8，9，10，11，12，13，14，15，18，20，25

先序遍历

先序遍历是试以优先于后代节点的顺序访问每个节点的。可以应用于打印树的结构文档。
如图：

访问顺序：11，7，5，3，6，9，8，10，15，13，12，14，20，18，25

后序遍历

后序遍历是先访问节点的后代节点，再访问节点本身。后序遍历可以应用于计算一个目录和它的子目录中所有文件所占空间的大小。
如图：

访问顺序：3，6，5，8，10，9，7，12，14，13，18，25，20，15，11

---

二叉树（BinarySearchTree）类应用

var tree = new BinarySearchTree();

tree.insert(11);
tree.insert(7);
tree.insert(15);
tree.insert(5);
tree.insert(3);
tree.insert(9);
tree.insert(8);
tree.insert(10);
tree.insert(13);
tree.insert(12);
tree.insert(14);
tree.insert(20);
tree.insert(18);
tree.insert(25);
tree.insert(6);//11,7,15,5,3,9,8,10,13,12,14,20,18,25,6

function printNode(value){
    console.log(value);
}
tree.inOrderTraverse(printNode);//中序遍历3，5，6，7，8，9，10，11，12，13，14，15，18，20，25

tree.preOrderTraverse(printNode);//先序遍历11，7，5，3，6，9，8，10，15，13，12，14，20，18，25

tree.postOrderTraverse(printNode);//后序遍历3，6，5，8，10，9，7，12，14，13，18，25，20，15，11

tree.max();//25
tree.min();//3
tree.remove(6);//删除6节点
tree.inOrderTraverse(printNode);
//中序遍历3，5，7，8，9，10，11，12，13，14，15，18，20，25
tree.getRoot()//11

---

ES6二叉树表完整实现代码：

let BinarySearchTree = (function() {
    class Node {
        constructor(key) {
            this.key = key;
            this.left = null;
            this.right = null;
        }
    }

    class BinarySearchTree {
        constructor() {
            this.root = null;
        }

        insert(key) {//向二叉树插入一个新的键
            var newNode = new Node(key);

            if(this.root === null) {
                this.root = newNode;
            } else {
                this.insertNode(this.root, newNode);
            }
        }

        insertNode(node, newNode) {
            if(newNode.key < node.key) {
                if(node.left === null) {
                    node.left = newNode;
                } else {
                    this.insertNode(node.left, newNode);
                }
            } else {
                if(node.right === null) {
                    node.right = newNode;
                } else {
                    this.insertNode(node.right, newNode);
                }
            }
        }

        getRoot() {//获取根节点
            return this.root;
        }

        search(key) {//在二叉树查找一个键，如果节点存在，则返回true；如果不存在，则返回false。
            return this.searchNode(this.root, key);
        }

        searchNode(node, key) {
            if(node === null) {
                return false;
            }

            if(key < node.key) {
                return this.searchNode(node.left, key);

            } else if(key > node.key) {
                return this.searchNode(node.right, key);

            } else {
                return true;
            }
        }

        inOrderTraverse(callback) {//通过中序遍历方式遍历所有节点
            this.inOrderTraverseNode(this.root, callback);
        }

        inOrderTraverseNode(node, callback) {
            if(node !== null) {
                this.inOrderTraverseNode(node.left, callback);
                callback(node.key);
                this.inOrderTraverseNode(node.right, callback);
            }
        }

        preOrderTraverse(callback) {//通过先序遍历方式遍历所有节点。
            this.preOrderTraverseNode(this.root, callback);
        }

        preOrderTraverseNode(node, callback) {
            if(node !== null) {
                callback(node.key);
                this.preOrderTraverseNode(node.left, callback);
                this.preOrderTraverseNode(node.right, callback);
            }
        }

        postOrderTraverse(callback) {//通过后序遍历方式遍历所有节点。
            this.postOrderTraverseNode(this.root, callback);
        }

        postOrderTraverseNode(node, callback) {
            if(node !== null) {
                this.postOrderTraverseNode(node.left, callback);
                this.postOrderTraverseNode(node.right, callback);
                callback(node.key);
            }
        }

        min() {//返回二叉树中最小的键值
            return this.minNode(this.root);
        }

        minNode(node) {
            if(node) {
                while(node && node.left !== null) {
                    node = node.left;
                }

                return node.key;
            }
            return null;
        }

        max() {//返回二叉树中最大的键值
            return this.maxNode(this.root);
        }

        maxNode(node) {
            if(node) {
                while(node && node.right !== null) {
                    node = node.right;
                }

                return node.key;
            }
            return null;
        }

        remove(element) {//从书中移除某个键
            this.root = this.removeNode(this.root, element);
        }

        findMinNode(node) {
            while(node && node.left !== null) {
                node = node.left;
            }

            return node;
        }

        removeNode(node, element) {

            if(node === null) {
                return null;
            }

            if(element < node.key) {
                node.left = this.removeNode(node.left, element);
                return node;

            } else if(element > node.key) {
                node.right = this.removeNode(node.right, element);
                return node;

            } else { 

                if(node.left === null && node.right === null) {
                    node = null;
                    return node;
                }


                if(node.left === null) {
                    node = node.right;
                    return node;

                } else if(node.right === null) {
                    node = node.left;
                    return node;
                }


                var aux = this.findMinNode(node.right);
                node.key = aux.key;
                node.right = this.removeNode(node.right, aux.key);
                return node;
            }
        };

    }
    return BinarySearchTree;
})()

相关文章

javascript AVL树算法与说明：http://blog.csdn.net/rth362147773/article/details/78014586
javascript 红黑树算法与说明：http://blog.csdn.net/rth362147773/article/details/78014688