數據結構 - 從二叉搜索樹說到AVL樹（一）之二叉搜索樹的操做與詳解（Java）

　　二叉搜索樹（Binary Search Tree），簡稱BST，顧名思義，一顆能夠用於搜索的二叉樹。BST在數據結構中佔有很重要的地位，一些高級樹結構都是其的變種，例如AVL樹、紅黑樹等，所以理解BST對於後續樹結構的學習有很好的做用。同時利用BST能夠進行排序，稱爲二叉排序，也是很重要的一種思想。

　　二叉樹的性質：任意一個節點的全部左子樹元素都比該元素值要小，而全部右子樹元素都比該元素值要大。

　　符合該性質的二叉樹就是一顆二叉搜索樹，固然前提下是樹中不容許有重複元素。

　　全部的二叉搜索樹的中序遍歷序列都是一個順序序列， 如下的幾種都是二叉搜索樹

　　

　　接下來說二叉搜索樹的三個主要操做：查找，增長，刪除。

　　1、查找

　　　　二叉搜索樹原本就是用於查找數據的一種結構，主要步驟是：

　　　　　　① 選擇根節點做爲當前節點

　　　　　　② 若是當前節點爲null，則返回false表示找不到該元素

　　　　　　③ 若是當前節點不爲null，判斷當前節點是否與所搜索元素相等，如相等，則返回true表示能找到該元素

　　　　　　④ 若是當前節點的值比所搜索值小，則選擇當前節點的左節點做爲當前節點，比搜索值大則選擇右節點做爲當前節點，而後從②循環過程

　　2、增長

　　　　二叉搜索樹增長節點重點是根據查找元素的過程找到該節點的插入位置：

　　　　　　① 若是根節點爲空，則當前插入（增長）的節點爲二叉樹的根，如根節點不爲空，設置根節點爲當前節點

　　　　　　② 若是當前節點的值與插入節點的值相等，返回false表示插入失敗，節點值已存在於樹中

　　　　　　③ 若插入節點的值比當前節點的值小，且當前節點的左子樹爲空，則把插入節點增長到當前節點的左子樹，並返回true表示插入成功，如左子樹不爲空，設置當前節點的左子樹爲當前節點。

　　　　　　　 若是插入節點的值比當前節點的值大，且當前節點的右子樹爲空，則把插入節點增長到當前節點的右子樹，並返回true，如右子樹不爲空，設置當前節點的右子樹爲當前節點。

　　　　　　　 從②循環過程

　　　　具體代碼以下：

    public boolean insert(int elem) {
        TreeNode node = new TreeNode(elem);
        if (null == this.root) {
            this.root = node;
            return true;
        } else {
            return insertChild(this.root, node);
        }
    }    
    /**
     * insert the newNode to the child position of parent node
     * @param parent
     * @param newNode
     * @return true if the newNode insert successfully or false if the newNode have been exist
     */
    private boolean insertChild(TreeNode parent, TreeNode newNode) {
        if (parent.getElem() == newNode.getElem()) {
            return false;
        } else if (parent.getElem() > newNode.getElem()) {
            if (null  == parent.getLeft()) {
               parent.setLeft(newNode);
               newNode.setParent(parent);
               return true;
            } else {
               return insertChild(parent.getLeft(), newNode);
            }
        } else {
            if (null == parent.getRight()) {
               parent.setRight(newNode);
               newNode.setParent(parent);
               return true;
            } else {
               return insertChild(parent.getRight(), newNode);
            }
        }
    }

　　3、刪除

　　　　二叉搜索樹的刪除操做重點在於刪除這個節點以後對其餘節點的重組，根據刪除節點位置又分爲如下幾種狀況：

　　　　　　狀況1 刪除節點爲葉子節點：直接刪除這個節點（把父節點對應的子樹設爲空）

　　　　　　狀況2 刪除節點只有左子樹或只有右子樹：用左子樹或者右子樹代替被刪除節點（把父節點對應的子樹指向刪除節點的左子樹或者右子樹，並把左子樹或右子樹的父節點指向刪除節點的父節點）

　　　　　　*狀況3 刪除節點的左子樹和右子樹均不爲空：找到刪除節點的直接前驅節點，用該前驅節點的值替換待刪除節點的值，而後把這個前驅節點當作待刪除節點，則該狀況轉換成狀況1或者狀況2

　　　　　　好比想刪除節點 4

　　　　

 

 　　　　　找到節點4的直接前驅節點3，用節點3的值代替節點4的值，而後狀況換成刪除節點3（也就是狀況1）。

　　　　具體代碼：

    /**
     * delete the node which element equals to parameter elem
     * @param elem
     * @return true if the node can be found and delete otherwise false
     */
    public boolean delete(int elem) {
        if (null == this.root) {
            return false;
        } else {
            TreeNode node = this.root;
            // find out the node need to be deleted
            while (null != node) {
                if (node.getElem() == elem) {
                    deleteNode(node);
                    return true;
                } else if (node.getElem() > elem) {
                    node = node.getLeft();
                } else {
                    node = node.getRight();
                }
            }
            return false;
        }
    }
    private void deleteNode(TreeNode node) {
        if (null == node.getLeft() && null == node.getRight()) {
            // deleted node is a leave
            if (null  == node.getParent()) {
                // deleted node is root
                this.root = null;
            } else if (node == node.getParent().getLeft()) {
                // deleted node is the left child of its parent
                node.getParent().setLeft(null);
            } else {
                // deleted node is the right child of its parent
                node.getParent().setRight(null);
            }
        } else if (null == node.getLeft()) {
            // deleted node only hae right child
            if (null  == node.getParent()) {
                this.root = node.getRight();
            } else if (node == node.getParent().getLeft()) {
                node.getParent().setLeft(node.getRight());
            } else {
                node.getParent().setRight(node.getRight());
            }
            node.getRight().setParent(node.getParent());
        } else if (null == node.getRight()) {
            // deleted node only have left child
            if (null  == node.getParent()) {
                this.root = node.getLeft();
            } else if (node == node.getParent().getLeft()) {
                node.getParent().setLeft(node.getLeft());
            } else {
                node.getParent().setRight(node.getLeft());
            }
            node.getLeft().setParent(node.getParent());
        } else {
            // deleted node have both left & right children
            // find out the precursor of deleted node
            // the precursor node replace the position of deleted node
            TreeNode pre = node.getLeft();
            while (null != pre.getRight()) {
                pre  = pre.getRight();
            }
            // swap the elem of precursor node and deleted node
            // then delete the precursor node
            TreeUtils.swapTreeElem(pre, node);
            deleteNode(pre);
        }
    }

寫個小程序測試一下：

輸入測試數據：10 5 2 7 6 18 13 -1（-1是結束輸入，不做爲一個元素值）

1. insert
2. delete
3. search
4. print
5. exit
->1
->10 5 2 7 6 18 13 -1
insert success

看一下樹的結構，顯示樹結構的須要順時針轉90°來看，並本身想象節點連線。。

1. insert
2. delete
3. search
4. print
5. exit
->4
-
    18
        13
10
        7
            6
    5
        2
-

刪除節點 5 測試效果

1. insert
2. delete
3. search
4. print
5. exit
->2
->5
delete success
--------------------------------------------------------------
1. insert
2. delete
3. search
4. print
5. exit
->4
-
    18
        13
10
        7
            6
    2
-

 至此， 二叉搜索樹的操做及具體實現完成，若有不妥之處，歡迎指出斧正。

 

 

尊重知識產權，轉載請標明出處並通知做者。