javaScript資料結構之樹

01 樹

樹是一種分層資料模型。

我曾經寫過一個json解析成影象來操作的外掛，用的就是樹的結構。

02 術語

• 樹的儲存單元叫做 節點
• 樹的頂部節點叫做 根節點
• 不是根節點，且有子節點的叫做 內部節點
• 沒有子節點的叫做 葉子節點
• 節點距離根節點的數目叫做 節點深度

03 二叉樹

所謂二叉樹—最多隻能有兩個子節點。 即左節點和右節點
二叉樹應用最為廣泛。

04 二叉搜尋樹

我們規定，二叉樹左側只能存放比本節點小的值，右側存放不小於本節點的值。 這樣子的樹，便於搜尋，我們稱為二叉搜尋樹。

05 實現二叉搜尋樹

先構建兩個基礎類，二叉搜尋樹類和節點類（私有類）

;(function(root) {
// 節點類
function Node(key) {
    this.key = key;
    this.left = null;
    this.right = null;
};
// 樹
function Tree() {
    var _root = null;
}
// 註冊公開類
root.Tree = Tree;
})(this);

實現新增方法

this.insert = function(key) {
    var newNode = new Node(key);
    if
 
 (_root === null) {
        _root = newNode;
    } else {
        // 遞迴新增
        insertNode(_root, newNode);
    }
};
function insertNode(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);
        }
    }
}

再實現遍歷方法

this.forEach = function(fn) {
    forEach(_root, fn);
};
function forEach(node, fn) {
    if (node != null) {
        fn(node.key);
        forEach(node.left, fn);
        forEach(node.right, fn);
    }
}

再實一個求最小值方法

this.min = function() {
    return minNode(_root).key;
};

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

最後實現移除方法

this.remove = function(key) {
    return remove(_root, key);
};
function remove(node, key) {
    if (node === null) {
        return null;
    };

    if (key < node.key) {
        node.left = remove(node.left, key);
        return node;
    } else if (key >　node.key) {
        node.right = remove(node.right, key);
        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 currNode = minNode(node.right);
        node.key = currNode.key;
        node.right = remove(node.right, currNode.key);
        return node;
    }
};

大功告成

;(function(root) {

function Node(key) {
    this.key = key;
    this.left = null;
    this.right = null;
};

function Tree() {
    var _root = null;
    this.insert = function(key) {
        var newNode = new Node(key);
        if (_root === null) {
            _root = newNode;
        } else {
            insertNode(_root, newNode);
        }
    };

    this.forEach = function(fn) {
        forEach(_root, fn);
    };

    this.min = function() {
        return minNode(_root).key;
    };

    this.max = function() {
        return maxNode(_root).key;
    };

    this.remove = function(key) {
        return remove(_root, key);
    };

    function remove(node, key) {
        if (node === null) {
            return null;
        };

        if (key < node.key) {
            node.left = remove(node.left, key);
            return node;
        } else if (key >　node.key) {
            node.right = remove(node.right, key);
            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 currNode = minNode(node.right);
            node.key = currNode.key;
            node.right = remove(node.right, currNode.key);
            return node;
        }
    };

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

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

    function forEach(node, fn) {
        if (node != null) {
            fn(node.key);
            forEach(node.left, fn);
            forEach(node.right, fn);
        }
    }

    function insertNode(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);
            }
        }
    }
};

root.Tree = Tree;

})(this);

我們測試一下：

var tree = new Tree();
tree.insert(2);
tree.insert(10);
tree.insert(6);
tree.insert(7);
tree.insert(8);
tree.insert(1);
tree.insert(55);
tree.insert(9);
tree.forEach(function (n){
    console.log(n);
});
console.log(tree.min());
tree.remove(55);
console.log(tree.max());