JavaScript数据结构——树

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

二叉树：二叉树中的节点最多只能有两个子节点（左侧子节点和右侧子节点）。这些定义有助于我们写出更高效的向／从树中插入、查找和删除节点的算法。

二叉搜索树：二叉树的一种，但是它只允许你在左侧节点存储（比父节点）小的值，在右侧节点存储（比父节点）大／等于的值。

 

遍历一棵树：是指访问树的每个节点并对它们进行某种操作的过程。访问树的所有节点有三种方式：中序、先序和后序。

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

先序遍历：是以优先于后代节点的顺序访问每个节点的。先序遍历的一种应用是打印一个结构化的文档。

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

搜索树中的值：在树中，有三种经常执行的搜索类型：最小值、最大值、搜索特定的值

 

BST 存在一个问题：取决于添加的节点树，树的一条边可能会非常深；也就是说，树的一条分支会有很多层，二其他的分支却只有几层。这会在需要在某条边上添加、移除和搜索某个节点时引起一些性能问题。

AVL树：为了解决 BST 的问题，有一种树叫作阿德尔森-维尔斯和兰迪斯树（AVL树）。AVL树是一种自平衡二叉搜索树，意思是任何一个节点两侧子树的高度之差最多为1。也就是说这种树会在添加或移除节点时尽量试着成为一棵完全树。

红黑树：特殊的二叉树，可以进行高效的中序遍历。

 

术语：

术语	解释
节点	树中的每个元素
根节点	树顶部的节点，没有父节点
内部节点	至少有一个子节点的节点
外部节点（叶节点）	没有子元素的节点
子树	由节点和它的后代构成
深度	节点的一个属性，取决于它的祖先节点的数量
高度	取决于所有节点深度的最大值

---------------------------------------------------------------------------------------------------------

二叉搜索树方法声明：

1. 和链表一样，通过指针来表示节点之间的关系（术语称其为边）；

2. 声明 Node 来表示树中的每个节点。

注意：不同于之前将节点本身称作节点或项，我们会称其为键。键是树相关的术语中对节点的称呼。

序号	方法	说明
1	insert(key)	向树中插入一个新的键
2	search(key)	在树中查找一个键，如果节点存在，则返回 true；如果不存在，则返回 false
3	inOrderTraverse	通过中序遍历方式遍历所有节点
4	preOrderTraverse	通过先序遍历方式遍历所有节点
5	postOrderTraverse	通过后序遍历方式遍历所有节点
6	min	返回树种最小的值/键
7	max	返回树种最大的值/键
8	remove(key)	从树中移除某个键

二叉搜索树的实现：

function BinarySearchTree() {
    // 辅助类Node定义
    var Node = function(key) {
        this.key = key;
        this.left = null;
        this.right = null;
    }
    var root = null;

    // 向树中插入一个新的键
    this.insert = function(key) {
        var newNode = new Node(key);

        if (root === null) {
            root = newNode;
        } else {
            insertNode(root, newNode);    // 私有的辅助函数
        }
    }

    this.insertNode = function(node, newNode) {
        if (newNode.key < node.key) {
            if (node.left === null) {
                node.left = newNode;
            } else {
                insertNode(node.left, newNode);    // 如果有左侧子节点，则通过递归调用继续找到树的下一层
            }
        } else {
            if (node.right === null) {
                node.right = newNode;
            } else {
                insertNode(node.right, newNode); // 如果有右侧子节点，则通过递归调用继续找到树的下一层
            }
        }
    }

    /* 中序遍历
     * inOrderTraverse方法接收一个回调函数作为参数。
     * 回调函数用来定义我们对遍历到的每个节点进行的操作（也叫访问者模式)
    */
    this.inOrderTraverse = function(callback) {
        inOrderTraverseNode(root, callback);
    }

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

    // 先序遍历
    this.preOrderTraverse = function(callback) {
        preOrderTraverseNode(root, callback);
    }

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

    // 后序遍历
    this.postOrderTraverse = function(allback) {
        postOrderTraverseNode(root, callback);
    }

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

    // 搜索树中的最小值
    this.min = function() {
        return minNode(root);
    }

    var minNode = function(node) {
        if (node) {
            while (node && node.left !== null) {
                node = node.lfet;
            }
            return node.key;
        }
        return null;
    }

    // 搜索树中的最大值
    this.max = function() {
        return maxNode(root);
    }

    this.maxNode = function(node) {
        if (node) {
            while (node && node.right !== null) {
                node = node.right;
            }
            return node.key;
        }
        return null;
    }

    // 搜索树中的特定值
    this.search = function(key) {
        return searchNode(root, key);
    }

    var searchNode = function(node, key) {
        if (node === null) {
            return false;
        }
        if (key < node.key) {
            return searchNode(node.left ,key);
        } else if (key > node.key) {
            return searchNode(node.right, key);
        } else {
            return true;
        }
    }

    // 从树中移除某个键
    this.remove = function(key) {
        root = removeNode(root, key);    // root被赋值为removeNode方法的返回值
    }

    var removeNode = function(node, key) {
        if (node === null) {    // 键不存在于树中，则返回null
            return null;
        }
        if (key < node.key) {    // 如果要找的键比当前节点的值小，就沿着树的左边找到下一个节点
            node.left = removeNode(node.left, key);
            return node;
        } else if (key > node.key) { // 如果要找的键比当前节点的值大，就沿着树的左边找到下一个节点
            node.right = removeNode(node.right, key);
            return node;
        } else {    // 键等于node.key

            // 第一种情况——一个叶节点
            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 = findMinNode(node.right);    
            node.key = aux.key;    // 用右侧子树中的最小节点的键去更新这个节点的值
            node.right = removeNode(node.right, aux.key);    // 移除右侧子树中的最小节点
            return node;
        }
    }
}

 

 参考书籍：《学习JavaScript数据结构与算法》