Map&Set之二叉搜索树

系列文章:

1. 先导片--Map&Set之二叉搜索树

2. Map&Set之相关概念

目录

前言

1.二叉搜索树

[1.1 定义](#1.1 定义)

[1.2 操作-查找](#1.2 操作-查找)

[1.3 操作-新增](#1.3 操作-新增)

[1.4 操作-删除(难点)](#1.4 操作-删除(难点))

[1.5 总体实现代码](#1.5 总体实现代码)

[1.6 性能分析](#1.6 性能分析)


前言

TreeMap 和 TreeSet 是 Java 中基于搜索树实现的 Map 和 Set。实际上,它们使用的是红黑树数据结构,而红黑树是一种近似平衡的二叉搜索树。在红黑树的基础上,还添加了颜色属性以及红黑树性质验证来确保树的平衡性,所以我们需要了解一下二叉搜索树这个概念。

1.二叉搜索树

1.1 定义

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

若它的左子树不为空,则左子树上所有节点的值都小于根节点的值
若它的右子树不为空,则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

1.2 操作-查找

如果根节点不为空:

如果根节点key == 查看key 返回true

如果根节点key > 查看key 在其左子树查找

如果根节点key < 查看key 在其右子树查找

否则返回false

实现代码:

java 复制代码
class BinarySearchTree {
    public static class Node {
        int key;
        Node left;
        Node right;

        public Node(int key) {
            this.key = key;
        }
    }

    private Node root = null;

    /**
     * 搜索
     * @param key
     * @return
     */
    public Node search(int key) {
        Node cur = root;
        while (cur != null){
            if(cur.key == key){
                return cur;
            }else if (key < cur.key){
                cur = cur.left;
            }else{
                cur = cur.right;
            }
        }
        return null;
    }
}

1.3 操作-新增

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

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

实现代码:

java 复制代码
class BinarySearchTree {
    public static class Node {
        int key;
        Node left;
        Node right;

        public Node(int key) {
            this.key = key;
        }
    }

    private Node root = null;

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

1.4 操作-删除(难点)

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

1.cur.left == null;

  1. cur 是 root ,则 root = cur.right
  2. cur 不是 root , cur 是 parent.left ,则 parent.left = cur.right
  1. 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
  1. cur 不是 root , cur 是 parent.right ,则 parent.right = cur.left

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

需要使用替换法进行删除,即在它的右子树中寻找中序下的第一个结点(关键码最小),用它的值填补到被删除节点中,再来处理该结点的删除问题。

实现代码:

java 复制代码
class BinarySearchTree {
    public static class Node {
        int key;
        Node left;
        Node right;

        public Node(int key) {
            this.key = key;
        }
    }

    private Node root = null;


    /**
     * 删除
     *
     * @param key
     * @return
     */
    public boolean delete(int key) {
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if (key == cur.key) {
                deleteValue(cur, parent);
                return true;
            } else if (key < cur.key) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        return false;
    }

    public void deleteValue(Node cur, Node parent) {
        //cur左右孩子都不在
        if (cur.left == null && cur.right == null) {
            if (parent.right == cur) {
                parent.right = null;
            } else {
                parent.left = null;
            }
            //cur左孩子不在
        }else if (cur.left == null) {
            if (cur == root) {
                root = root.right;
            } else if (cur == parent.right) {
                parent.right = cur.right;
            } else {
                parent.left = cur.right;
            }
            //cur右孩子不在
        }else if (cur.right == null) {
            if (cur == root) {
                root = root.left;
            } else if (cur == parent.right) {
                parent.right = cur.left;
            } else {
                parent.left = cur.left;
            }
            //左右均在
        }else{
            //为删除节点的右节点
            Node target = cur.right;
            Node targetParent = cur;
            //找右树最左节点
            while (target.left != null){
                targetParent = target;
                target = target.left;
            }
            cur.key = target.key;
            if(targetParent.left == target){
                targetParent.left = target.right;
            }else{
                targetParent.right = target.right;
            }
        }
    }
}

1.5 总体实现代码

java 复制代码
class BinarySearchTree {
    public static class Node {
        int key;
        Node left;
        Node right;

        public Node(int key) {
            this.key = key;
        }
    }

    private Node root = null;

    /**
     * 搜索
     *
     * @param key
     * @return
     */
    public Node search(int key) {
        Node cur = root;
        while (cur != null) {
            if (cur.key == key) {
                return cur;
            } else if (key < cur.key) {
                cur = cur.left;
            } else {
                cur = cur.right;
            }
        }
        return null;
    }

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

    /**
     * 删除
     *
     * @param key
     * @return
     */
    public boolean delete(int key) {
        Node cur = root;
        Node parent = null;
        while (cur != null) {
            if (key == cur.key) {
                deleteValue(cur, parent);
                return true;
            } else if (key < cur.key) {
                parent = cur;
                cur = cur.left;
            } else {
                parent = cur;
                cur = cur.right;
            }
        }
        return false;
    }

    public void deleteValue(Node cur, Node parent) {
        //cur左右孩子都不在
        if (cur.left == null && cur.right == null) {
            if (parent.right == cur) {
                parent.right = null;
            } else {
                parent.left = null;
            }
            //cur左孩子不在
        }else if (cur.left == null) {
            if (cur == root) {
                root = root.right;
            } else if (cur == parent.right) {
                parent.right = cur.right;
            } else {
                parent.left = cur.right;
            }
            //cur右孩子不在
        }else if (cur.right == null) {
            if (cur == root) {
                root = root.left;
            } else if (cur == parent.right) {
                parent.right = cur.left;
            } else {
                parent.left = cur.left;
            }
            //左右均在
        }else{
            //为删除节点的右节点
            Node target = cur.right;
            Node targetParent = cur;
            //找右树最左节点
            while (target.left != null){
                targetParent = target;
                target = target.left;
            }
            cur.key = target.key;
            if(targetParent.left == target){
                targetParent.left = target.right;
            }else{
                targetParent.right = target.right;
            }
        }
    }
}

1.6 性能分析

在二叉搜索树中,插入和删除操作都需要先进行查找。查找的效率直接影响了这些操作的性能。对于一个有n个节点的二叉搜索树,如果每个元素被查找的概率相等,那么平均查找长度将取决于节点在二叉搜索树中的深度。换句话说,节点越深,需要进行的比较次数就越多。

然而,对于相同的关键码集合,如果插入关键码的顺序不同,可能会得到不同结构的二叉搜索树。这是因为二叉搜索树的性质要求左子树的所有节点的值小于根节点的值,右子树的所有节点的值大于根节点的值。因此,不同的插入顺序可能会导致树的结构有所不同,从而影响查找效率。
最优情况下,二叉搜索树为完全二叉树,其平均比较次数为:log(N)

最差情况下,二叉搜索树退化为单支树,其平均比较次数为:N/2

相关推荐
pianmian13 小时前
python数据结构基础(7)
数据结构·算法
好奇龙猫5 小时前
【学习AI-相关路程-mnist手写数字分类-win-硬件:windows-自我学习AI-实验步骤-全连接神经网络(BPnetwork)-操作流程(3) 】
人工智能·算法
sp_fyf_20245 小时前
计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-11-01
人工智能·深度学习·神经网络·算法·机器学习·语言模型·数据挖掘
ChoSeitaku6 小时前
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
数据结构·考研·链表
偷心编程6 小时前
双向链表专题
数据结构
香菜大丸6 小时前
链表的归并排序
数据结构·算法·链表
jrrz08286 小时前
LeetCode 热题100(七)【链表】(1)
数据结构·c++·算法·leetcode·链表
oliveira-time6 小时前
golang学习2
算法
@小博的博客6 小时前
C++初阶学习第十弹——深入讲解vector的迭代器失效
数据结构·c++·学习
南宫生7 小时前
贪心算法习题其四【力扣】【算法学习day.21】
学习·算法·leetcode·链表·贪心算法