二叉樹刪除節點

---

二叉樹刪除節點的分爲三種情況：
①當待刪除節點是葉子節點，那麼只需要將從父節點指向它的鏈接指向null。
②待刪除節點只包含一個子節點，那麼原本指向它的節點就得使其指向它的子節點。
③待刪除節點包含兩個子節點，那麼我們可以採用兩種方式，一種是查找待刪除節點左子樹上的最大值，一種是查找待刪除節點右節點上的最小值。
先如今我先採用後中方式：找Min 值 作爲臨時節點 —->>>頂替刪除的節點—–>>>>>>刪除這個臨時節點。

---

代碼解析：
getSmallest: 是獲取Min的函數。
remove：
removeNode：（這個函數纔是關鍵，需要自己明白每一步，最好每一步都自己console.log一遍）

function getSmallest( node ){
            while(node.left != null ){
                node = node.left;
            } 
            return node;
        }

        function remove( data ){
            root = removeNode( this.root, data );
        }

        function removeNode(node, data){
            if( node == null ){
                return null;
            }
            if( data == node.data ){
                if( node.left == null && node.right == null ){
                    return null;
                }
                if( node.left == null ){
                    return node.right;
                }
                if(node.right == null){
                    return node.left;
                }
                var tempNode = getSmallest(node.right);
                node.data = tempNode.data;
                        node.right = removeNode(node.right,    tempNode.data);
                return node;
            }else if( data < node.data ){
                node.left = removeNode( node.left, data );
                return node;
            }else{
                node.right = removeNode(node.right, data);
                return node;
            }
        }



----------
    附錄完整的代碼：

    function Node(data, left, right){
            this.data = data;
            this.show = show;
            this.left = left;
            this.right = right;
        }

        function show(){
            return this.data;
        }

        function BST(){
            this.root = null;
            this.insert = insert;
            this.inOrder = inOrder;
            this.remove = remove;
            this.removeNode = removeNode;
            this.getSmallest = getSmallest;
        }

        function insert(data){
            var n = new Node( data, null, null );
            if(  this.root == null ){
                this.root = n;
            }else{
                var current = this.root;
                var parent;
                while(true){
                    if(  data < current.data ){
                        parent = current;
                        current = current.left;
                        if( current == null ){
                            parent.left = n;
                            break;
                        }
                    }else{
                        parent = current;
                        current = current.right;
                        if( current == null ){
                            parent.right = n;
                            break;
                        }
                    }
                }
            }
        }

        function inOrder( node ){
            if( !( node == null ) ){
                inOrder(node.left);
                console.log( node.show() + "  " );
                inOrder(node.right);
            }
        }
        function getSmallest( node ){
            while(node.left != null ){
                node = node.left;
            } 
            return node;
        }

        function remove( data ){
            root = removeNode( this.root, data );
        }

        function removeNode(node, data){
            if( node == null ){
                return null;
            }
            if( data == node.data ){
                if( node.left == null && node.right == null ){
                    return null;
                }
                if( node.left == null ){
                    return node.right;
                }
                if(node.right == null){
                    return node.left;
                }
                var tempNode = getSmallest(node.right);
                node.data = tempNode.data;
                node.right = removeNode(node.right, tempNode.data);
                return node;
            }else if( data < node.data ){
                node.left = removeNode( node.left, data );
                return node;
            }else{
                node.right = removeNode(node.right, data);
                return node;
            }
        }


        var nums = new BST();
        nums.insert(23);
        nums.insert(45);
        nums.insert(16);
        nums.insert(37);
        nums.insert(3);
        nums.insert(99);
        nums.insert(22);
        console.log("After sort:");
        console.log( nums.inOrder(  nums.root ) );
        nums.remove(3);
        console.log("after remove: ");
        console.log( nums.inOrder(  nums.root ) );
        nums.remove(45);
        console.log("after remove: ");
        console.log( nums.inOrder(  nums.root ) );

最後附上測試截圖：

說一下：這裏的核心代碼是在 《數據結構與算法 Javascript描述》中
大傢伙最近去看看吧