快捷導(dǎo)航

Java深入了解數(shù)據(jù)結(jié)構(gòu)之二叉搜索樹增插刪創(chuàng)詳解

更新時間：2022年01月27日 15:13:24 作者：/少司命

二叉搜索樹是以一棵二叉樹來組織的。每個節(jié)點(diǎn)是一個對象，包含的屬性有l(wèi)eft，right，p和key，其中，left指向該節(jié)點(diǎn)的左孩子，right指向該節(jié)點(diǎn)的右孩子，p指向該節(jié)點(diǎn)的父節(jié)點(diǎn)，key是它的值

①概念

二叉搜索樹又稱二叉排序樹，它或者是一棵空樹**，或者是具有以下性質(zhì)的二叉樹:

若它的左子樹不為空，則左子樹上所有節(jié)點(diǎn)的值都小于根節(jié)點(diǎn)的值

若它的右子樹不為空，則右子樹上所有節(jié)點(diǎn)的值都大于根節(jié)點(diǎn)的值

它的左右子樹也分別為二叉搜索樹

②操作-查找

二叉搜索樹的查找類似于二分法查找

public Node search(int key) {
        Node cur = root;
        while (cur != null) {
            if(cur.val == key) {
                return cur;
            }else if(cur.val < key) {
                cur = cur.right;
            }else {
                cur = cur.left;
            }
        }
        return null;
    }

③操作-插入

  public boolean insert(int key) {
        Node node = new Node(key);
        if(root == null) {
            root = node;
            return true;
        }
 
        Node cur = root;
        Node parent = null;
 
        while(cur != null) {
            if(cur.val == key) {
                return false;
            }else if(cur.val < key) {
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
        //parent
        if(parent.val > key) {
            parent.left = node;
        }else {
            parent.right = node;
        }
 
        return true;
    }

④操作-刪除

刪除操作較為復(fù)雜，但理解了其原理還是比較容易

設(shè)待刪除結(jié)點(diǎn)為 cur, 待刪除結(jié)點(diǎn)的雙親結(jié)點(diǎn)為 parent

1. cur.left == null

1. cur 是 root，則 root = cur.right

2. cur 不是 root，cur 是 parent.left，則 parent.left = cur.right

3. cur 不是 root，cur 是 parent.right，則 parent.right = cur.right

2. cur.right == null

1. cur 是 root，則 root = cur.left

2. cur 不是 root，cur 是 parent.left，則 parent.left = cur.left

3. cur 不是 root，cur 是 parent.right，則 parent.right = cur.left

第二種情況和第一種情況相同，只是方向相反，這里不再畫圖

3. cur.left != null && cur.right != null

需要使用替換法進(jìn)行刪除，即在它的右子樹中尋找中序下的第一個結(jié)點(diǎn)(關(guān)鍵碼最小)，用它的值填補(bǔ)到被刪除節(jié)點(diǎn)中，再來處理該結(jié)點(diǎn)的刪除問題

當(dāng)我們在左右子樹都不為空的情況下進(jìn)行刪除，刪除該節(jié)點(diǎn)會破壞樹的結(jié)構(gòu)，因此用替罪羊的方法來解決，實(shí)際刪除的過程還是上面的兩種情況，這里還是用到了搜索二叉樹的性質(zhì)

public void remove(Node parent,Node cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = cur.right;
            }else if(cur == parent.left) {
                parent.left = cur.right;
            }else {
                parent.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = cur.left;
            }else if(cur == parent.left) {
                parent.left = cur.left;
            }else {
                parent.right = cur.left;
            }
        }else {
            Node targetParent =  cur;
            Node target = cur.right;
            while (target.left != null) {
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;
            if(target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }
 
  public void removeKey(int key) {
        if(root == null) {
            return;
        }
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if(cur.val == key) {
                remove(parent,cur);
                return;
            }else if(cur.val < key){
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
    }

⑤性能分析

插入和刪除操作都必須先查找，查找效率代表了二叉搜索樹中各個操作的性能。

對有n個結(jié)點(diǎn)的二叉搜索樹，若每個元素查找的概率相等，則二叉搜索樹平均查找長度是結(jié)點(diǎn)在二叉搜索樹的深度的函數(shù)，即結(jié)點(diǎn)越深，則比較次數(shù)越多。

但對于同一個關(guān)鍵碼集合，如果各關(guān)鍵碼插入的次序不同，可能得到不同結(jié)構(gòu)的二叉搜索樹：

最優(yōu)情況下，二叉搜索樹為完全二叉樹，其平均比較次數(shù)為：

最差情況下，二叉搜索樹退化為單支樹，其平均比較次數(shù)為：

⑥完整代碼

public class TextDemo {
 
    public static class Node {
        public int val;
        public Node left;
        public Node right;
 
        public Node (int val) {
            this.val = val;
        }
    }
 
 
    public Node root;
 
    /**
     * 查找
     * @param key
     */
    public Node search(int key) {
        Node cur = root;
        while (cur != null) {
            if(cur.val == key) {
                return cur;
            }else if(cur.val < key) {
                cur = cur.right;
            }else {
                cur = cur.left;
            }
        }
        return null;
    }
 
    /**
     *
     * @param key
     * @return
     */
    public boolean insert(int key) {
        Node node = new Node(key);
        if(root == null) {
            root = node;
            return true;
        }
 
        Node cur = root;
        Node parent = null;
 
        while(cur != null) {
            if(cur.val == key) {
                return false;
            }else if(cur.val < key) {
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
        //parent
        if(parent.val > key) {
            parent.left = node;
        }else {
            parent.right = node;
        }
 
        return true;
    }
 
    public void remove(Node parent,Node cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = cur.right;
            }else if(cur == parent.left) {
                parent.left = cur.right;
            }else {
                parent.right = cur.right;
            }
        }else if(cur.right == null) {
            if(cur == root) {
                root = cur.left;
            }else if(cur == parent.left) {
                parent.left = cur.left;
            }else {
                parent.right = cur.left;
            }
        }else {
            Node targetParent =  cur;
            Node target = cur.right;
            while (target.left != null) {
                targetParent = target;
                target = target.left;
            }
            cur.val = target.val;
            if(target == targetParent.left) {
                targetParent.left = target.right;
            }else {
                targetParent.right = target.right;
            }
        }
    }
 
    public void removeKey(int key) {
        if(root == null) {
            return;
        }
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if(cur.val == key) {
                remove(parent,cur);
                return;
            }else if(cur.val < key){
                parent = cur;
                cur = cur.right;
            }else {
                parent = cur;
                cur = cur.left;
            }
        }
    }
 
}

到此這篇關(guān)于Java深入了解數(shù)據(jù)結(jié)構(gòu)之二叉搜索樹增插刪創(chuàng)詳解的文章就介紹到這了,更多相關(guān)Java 二叉搜索樹內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: