【DS】二叉搜索树的介绍和实现

✨博客主页: 心荣~
✨系列专栏:【Java实现数据结构】
✨一句短话: 难在坚持,贵在坚持,成在坚持!

一. 什么是二叉搜索树

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

• 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
• 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
• 它的左右子树也分别为二叉搜索树
• 中序遍历二叉搜索树，得到的序列是依次递增的
• 二叉搜索树的结点的值不能发生重复

int a [] = {5,3,4,1,7,8,2,6,0,9};

二. 简单实现一下搜索树

1. 节点结构

static class TreeNode {
        public int val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }
1
2
3
4
5
6
7
8
9

2. 查找操作

二叉搜索树的存在就是为了方便查找的，根据二叉搜索树的特点，左子树的元素比根小，右子树的元素比根大，所以我们需要根据根节点的值与目标元素的值比较去实现查找

• 根与目标元素相等，表示找到了;
• 目标元素比根小，去左子树找;
• 目标元素比根大，去右子树找;
• 左右子树都找不到，则树中不存在要找的元素

代码实现:

//查找元素
    public TreeNode search(int key) {
        TreeNode cur = root;
        while(cur != null) {
            if(key < cur.val) {
                cur = cur.left;
            }else if(key > cur.val) {
                cur = cur.right;
            }else{
                return cur;
            }
        }
        return null;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. 插入操作

想要在二叉搜索树中插入一个元素，那么就得找到一个可以的插入位置，我们可以利用二叉树的搜索方式去找到一个合适的空位置进行插入;

1. 如果树为空树，即根 == null，直接插入

2. 如果树不是空树，按照查找逻辑确定插入位置，插入新结点

• 根与插入元素相等，树中已经有了这个元素了, 不能重复插入;
• 根比插入元素大，去左子树找;
• 根比插入元素小，去右子树找;
• 找到的结点为空，那这个位置就是我们要找的空位。

代码实现:

//插入元素
    public boolean insert (int key) {
        if(root == null) {
            root = new TreeNode(key);
            return true;
        }
        TreeNode parent = null;
        TreeNode cur = root;
        while(cur != null) {
            if(key < cur.val) {
                parent = cur;
                cur = cur.left;
            }else if(key > cur.val) {
                parent = cur;
                cur = cur.right;
            }else{
                return false;//树中不能有重复的元素
            }
        }
        TreeNode node = new TreeNode(key);
        if(key < parent.val) {
            parent.left = node;
        }else{
            parent.right = node;
        }
        return true;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

4. 删除操作

删除情况主要是下面三种场景下的删除, 具体分析如下:

设待删除结点为 cur, 待删除结点的双亲结点为 parent

1. cur.left == null

• cur 是 root，则 root = cur.right
• cur 不是 root，cur 是 parent.left，则 parent.left = cur.right
• cur 不是 root，cur 是 parent.right，则 parent.right = cur.right

2. cur.right == null

• cur 是 root，则 root = cur.left
• cur 不是 root，cur 是 parent.left，则 parent.left = cur.left
• cur 不是 root，cur 是 parent.right，则 parent.right = cur.left

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

• 可以使用替换法(替罪羊法)进行删除，即在它的右子树中寻找值最小的节点，用它的值填补到被删除节点中，再将这个最小值节点删除即可, 右子树节点的最小值节点的右子树一定是为空的, 所以此时的删除操作又和上面的2类似了; 同样的,也可以采用去找要删除节点左子树的最大值来实现;
• 最容易忽略的一点是, 找要删除节点的右子树的最小值为例, 如果右子树节点中没有左子树只有右子树; 此时与上面的情况就不相同了

//删除元素
    public void romove(int key) {
        TreeNode parent = null;
        TreeNode cur = root;
        while(cur != null) {
            if(key < cur.val) {
                parent = cur;
                cur = cur.left;
            }else if(key > cur.val) {
                parent = cur;
                cur = cur.right;
            }else{
                romoveNode(parent, cur);
                return true;
            }
        } 
        return false;
    }
    private void romoveNode(TreeNode parent, TreeNode cur) {
        if(cur.left == null) {
            if(cur == root) {
                root = cur.right;
            }else if(cur == parent.left) {
                parent.left = cur.right;
            }else if(cur == parent.right){
                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 if(cur == parent.right){
                parent.right = cur.left;
            }
        }else {
            TreeNode target = cur.right;
            TreeNode targetParent = cur;
            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;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

5. 修改操作

搜索树的修改可以基于删除和插入操作来实现，先将目标元素删除(确定有删除的元素才能有插入操作)，然后再插入修改元素(不能重复插入)。

//修改元素
    public void set(int key, int val){
        if(romove(key)) {
            insert(val);
        }
    }
1
2
3
4
5
6

三. 性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树，时间复杂度为: O(logN)

最差情况下，二叉搜索树退化为单支树，其平均比较次数为: O(N)