TreeMap和TreeSet

于 2024-10-10 16:24:30 发布
阅读量1.1k 收藏 27
点赞数 28
分类专栏： DS 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79249715/article/details/142824888
版权

在这里插入图片描述

前言

在了解TreeSet和TreeMap之前，先让我们介绍一下搜索树的概念。

1. 搜索树

二叉搜索树又称二叉排序树，这颗树要么是一棵空树，要么是具有以下性质的二叉树：

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

在这里插入图片描述

那么对于一颗二叉排序树应该具有的基本操作是什么呢？我们知道作为一颗二叉排序树一定满足的条件是左子树上的所有结点都小于根节点，右子树上的所有结点都大于根节点。因此对于一颗二叉搜索树而言，我们应该存在查找、插入、删除的操作。

1.1 查找

二叉排序树根节点的左子树都小于根节点，根节点的右子树都大于右子树，基于这个特点，我们可以按照以下规律查找：

从根节点开始比较，当待查找的结点大于根节点时，我们就到右子树中去找；当待查找的结点小于根节点是，我们就到左子树中去找；当待查找的结点等于根节点时，此时直接返回根节点就可；当查找完整棵树发现该节点不存在时，返回null

//二叉排序树查找操作的实现：
public TreeNode search(int key) {  
    if(isEmpty()) {  
        throw new EmptyException("查找树为空，无法查找");  
    }  
    TreeNode cur = this.root;  
    while(cur != null) {  
        if(cur.val > key) {  
            cur = cur.left;  
        }else if(cur.val < key) {  
            cur = cur.right;  
        }else {  
            return cur;  
        }  
    }  
    return null;  
  
}

1.2 插入

二叉排序树中不能插入相同的元素，当元素已存在时插入失败，也就说二叉排序树中所有数据都是只有一份的。对于插入操作，我们会根据二叉排序树的性质遍历整棵树找到适合的位置进行插入，使得插入结束后仍然是一颗搜索树。

public boolean insert(int key) {  
    TreeNode node = new TreeNode(key);  
    if(isEmpty()) {  
        this.root = node;  
        return true;    }  
    TreeNode cur = this.root;  
    TreeNode parent = null;  
    while(cur != null) {  
        parent = cur;  
        if(cur.val > key) {  
            cur = cur.left;  
        }else if(cur.val < key) {  
            cur = cur.right;  
        }else {  
            System.out.println("插入失败，key值已存在");  
            return false;        }  
    }  
    //找到可插入节点的父节点，判断往结点那边插入  
    if(parent.val > key) {  
        parent.left = node;  
    }else {  
        parent.right = node;  
    }  
    return true;  
}

再插入过程中需要注意保存可插入结点的父节点，同时注意判断往可插入节点的父节点的那边进行插入。

1.3 删除(较难)

设待删除结点为cur,待删除结点的父节点为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，待删除结点的父节点的右子树等于删除结点的右子树结点。
  1. 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，待删除结点的父节点的右子树等于删除结点的左子树结点。
  1. cur.left != null && cur.right != null,待删除结点的左右子树都不为空

对于左右子树都不为空的情况下，我们可以使用替换删除法，即寻找一个合适的值来替代掉原来的数，让后将这个“合适的数”原来所在的位置删除掉。

#合适的数： 待删除结点的左子树中的最大值（左子树中的最右边结点）或者待删除结点的右子树中的最小值（右子树中的最左边结点）。

public boolean remove(int key) {  
    if(isEmpty()) {  
        throw new EmptyException("数为空，无法删除");  
    }  
    //找到要删除结点，同时保存他的父节点  
    TreeNode cur = this.root;  
    TreeNode parent = null;  
    while(cur != null) {  
        parent = cur ;  
        if(cur.val > key) {  
            cur = cur.left;  
        }else if(cur.val < key) {  
            cur = cur.right;  
        }else {  
            //找到删除节点了,删除  
            removeNode(parent,cur);  
            return true;        }  
    }  
    System.out.println("删除节点不存在");  
    return false;  
}  
  
//删除结点存在的情况  
//1. 左边为空  
//2. 右边为空  
//3. 左右为空  
//4. 左右不为空  
private void removeNode(TreeNode parent, TreeNode cur) {  
    //删除结点可能是根节点，此时parent结点==null，且记得修改根节点  
    if(cur.left == null) {  
        //同时包括1、3  
        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) {  
        //处理2  
        if(cur == root) {  
            root = cur.left;  
        }else if(cur == parent.left) {  
            parent.left = cur.left;  
        }else {  
            parent.right = cur.left;  
        }  
    }else {  
        //左右结点都不为空  
        //删除结点：替换删除法:找到替换当前结点的左子树中的最大值（最右结点），或右子树的最小值（最左结点）  
        //将找的值替换到删除结点，然后删去找到替换的值的结点  
        TreeNode targetParent = cur;  
        TreeNode target = cur.right;  
        while(target.left != null) {  
            targetParent = target;  
            target = target.left;  
            //迭代寻找最右子树最左边结点  
        }  
        //替换  
        cur.val = target.val;  
        //右子树中不一定存在左子树，所以最小值可能是右子树的根节点  
        //判断是否存在左分支  
        if(targetParent.left == target) {  
            targetParent.left = target.right;  
        }else {  
            targetParent.right = target.right;  
        }  
    }  
}

这里的替换删除中的最合适的数为右子树中的最小值，targerParent结点保存的是合适结点的父节点，需要特别注意的是：在右子树中寻找最小值时，最小值可能是右子树的根节点，所以我们应该判断最小值是不是根节点。

1.4 搜索树的模拟实现

/**  
 * 二叉搜索树  
 * 时间复杂度：  
 * 好的：O（LogN）  
 * 坏的：O（N），单分支  
 */  
public class BinarySearchTree {  
    static class TreeNode {  
        public int val;  
        public TreeNode left;  
        public TreeNode right;  
  
        public TreeNode(int val) {  
            this.val = val;  
        }  
    }  
    public TreeNode root;  
  
    //插入得保存父节点  
    public boolean insert(int key) {  
        TreeNode node = new TreeNode(key);  
        if(isEmpty()) {  
            this.root = node;  
            return true;        }  
        TreeNode cur = this.root;  
        TreeNode parent = null;  
        while(cur != null) {  
            parent = cur;  
            if(cur.val > key) {  
                cur = cur.left;  
            }else if(cur.val < key) {  
                cur = cur.right;  
            }else {  
                System.out.println("插入失败，key值已存在");  
                return false;            }  
        }  
        //找到可插入节点的父节点，判断往结点那边插入  
        if(parent.val > key) {  
            parent.left = node;  
        }else {  
            parent.right = node;  
        }  
        return true;  
    }  
  
    /**  
     * 搜索元素  
     * 时间复杂度：好的情况下：O（LogN）  
     * 坏的情况下：O（N）  
     * @param key  
     * @return  
     */  
  
    public TreeNode search(int key) {  
        if(isEmpty()) {  
            throw new EmptyException("查找树为空，无法查找");  
        }  
        TreeNode cur = this.root;  
        while(cur != null) {  
            if(cur.val > key) {  
                cur = cur.left;  
            }else if(cur.val < key) {  
                cur = cur.right;  
            }else {  
                return cur;  
            }  
        }  
        return null;  
  
    }  
    public boolean isEmpty() {  
        return this.root == null;  
    }  
  
    public boolean remove(int key) {  
        if(isEmpty()) {  
            throw new EmptyException("数为空，无法删除");  
        }  
        //找到要删除结点，同时保存他的父节点  
        TreeNode cur = this.root;  
        TreeNode parent = null;  
        while(cur != null) {  
            parent = cur ;  
            if(cur.val > key) {  
                cur = cur.left;  
            }else if(cur.val < key) {  
                cur = cur.right;  
            }else {  
                //找到删除节点了,删除  
                removeNode(parent,cur);  
                return true;            }  
        }  
        System.out.println("删除节点不存在");  
        return false;  
    }  
  
    //删除结点存在的情况  
    //1. 左边为空  
    //2. 右边为空  
    //3. 左右为空  
    //4. 左右不为空  
    private void removeNode(TreeNode parent, TreeNode cur) {  
        //删除结点可能是根节点，此时parent结点==null，且记得修改根节点  
        if(cur.left == null) {  
            //同时包括1、3  
            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) {  
            //处理2  
            if(cur == root) {  
                root = cur.left;  
            }else if(cur == parent.left) {  
                parent.left = cur.left;  
            }else {  
                parent.right = cur.left;  
            }  
        }else {  
            //左右结点都不为空  
            //删除结点：替换删除法:找到替换当前结点的左子树中的最大值（最右结点），或右子树的最小值（最左结点）  
            //将找的值替换到删除结点，然后删去找到替换的值的结点  
            TreeNode targetParent = cur;  
            TreeNode target = cur.right;  
            while(target.left != null) {  
                targetParent = target;  
                target = target.left;  
                //迭代寻找最右子树最左边结点  
            }  
            //替换  
            cur.val = target.val;  
            //右子树中不一定存在左子树，所以最小值可能是右子树的根节点  
            //判断是否存在左分支  
            if(targetParent.left == target) {  
                targetParent.left = target.right;  
            }else {  
                targetParent.right = target.right;  
            }  
        }  
    }  
  
}

我们知道在数据的插入和删除过程中，二叉搜索树最优的情况下能够化为一颗完全二叉树，其平局比较次数为LogN；在最坏的情况下二叉搜索树会退化为一颗单分支的数，其平均比较此事为N/2
在这里插入图片描述

2. TreeSet和TreeMap

TreeMap 和 TreeSet 中利用搜索树实现的 Map 和 Set；实际上它们底层中用的数据结构是红黑树，而红黑树是一棵近似平衡的二叉搜索树，即在二叉搜索树的基础之上 + 颜色以及红黑树性质验证。

#模型：一般把搜索的数据称为关键字（Key），和关键字对应的称为值（Value），将其称之为Key-value的键值对，所以模型通常会有两种
模型会有两种：

  1. 纯Key模型，如：
  • 快速查找一个单词是否在词典中
  • 快速查找某个名字在不在通讯录中
  1. Key-Value模型，如：
  • 统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次数>
  • 梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号

Map中存储的就是key-value的键值对，Set中只存储了Key。

对于TreeMap和TreeSet，我们将从以下方面进行切入介绍：相同点、不同点、还有常用方法。

2.1 异同点

相同点：

  1. TreeMap和TreeSet底层使用了红黑树，也就是说它们都是有序的集合，他们存储的值都是拍好序的。
  2. 运行速度都要比Hash集合慢，他们内部对元素的操作时间复杂度为O(logN)，而HashMap/HashSet则为O(1)
  3. 由于 TreeMap和TreeSet底层使用了红黑树，所以当我们实现元素插入的时候，插入的一定是个能够比较的大小的数据(实现Comparable接口或者提供比较器)
    不同点：
  4. 最主要的区别就是TreeSet和TreeMap非别实现Set和Map接口
  5. TreeSet只存储一个对象(Key)，而TreeMap存储两个对象(Key和Value)，对于TreeMap中仅仅Key对象有序
  6. TreeSet中不存在重复集合（天然去重的集合），即Key的值不会重复；而TreeMap中却拥有可以重复的Value值，存放键值对的Key是唯一的，value是可以重复的

2.2 TreeMap的常见方法

方法介绍
V get(Object key)返回 key 对应的 value
V put(K key, V value)将Key和Value作为键值对，添加到Map中
boolean containsKey(Object key)如果Map中存在key则返回true
V getOrDefault(Object key, V defaultValue)如果Map中有关于key对应的value
则返回Map中的value, 否则返回默认设置的value
Set<Map.Entry<K,V>> entrySet()返回一个set集合，里面的元素是Map.Entry<K, V>

#Map.Entry<K,V>:Map.Entry<K, V> 是Map内部实现的用来存放<key, value>键值对映射关系的内部类，该内部类中主要提供了<key, value>的获取，value的设置以及Key的比较方式。

方法介绍
K getKey()获得entry 中的 key
V getValue()获得entry 中的 value
import java.util.Map;  
import java.util.Set;  
import java.util.TreeMap;  
  
public class Test {  
    public static void main(String[] args) {  
        Map<String, Integer> treeMap = new TreeMap<>();  
  
        //put（Key,Value）存放键值对Key-Value  
        //Key在这里是String类型的name  
        //Value在这里是Integer类型的age  
        System.out.println("-----put(Key,Value)....");  
        treeMap.put("张三", 18);  
        treeMap.put("李四", 22);  
        treeMap.put("王五", 21);  
  
        //get(Key)获取Key"王五"对应的Value年龄  
        System.out.println("-----get(Key)....");  
        Integer age = treeMap.get("王五");  
        System.out.println(age);  
  
        //查看treeMap里是否有"李四"  
        System.out.println("-----containsKey(Object key)....");  
        boolean ret = treeMap.containsKey("李四");  
        System.out.println(ret);  
  
        //getOrDefault(Object key, V defaultValue)  
        System.out.println("-----getOrDefault(Object key , V defaultValue)....");  
        System.out.println(treeMap.getOrDefault("张三", 20));  
        System.out.println(treeMap.getOrDefault("钱七", 20));  
  
        //将treeMap转化为一个Set集合  
        //获取Entry对象，然后获取key和value  
        System.out.println("-----Set<Map.Entry<K,V>> entrySet()....");  
        for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {  
            System.out.println("Key == " + entry.getKey() + "   Value == " + entry.getValue());  
        }  
  
    }  
}

运行结果：
在这里插入图片描述

2.3 TreeSet的常用方法

方法解释
boolean add(E e)添加集合中不存在元素，重复元素不会被添加成功
boolean contains(Object o)判断 o 是否在集合中
Iterator< E > iterator()返回迭代器对象
boolean remove(Object o)删除集合中的 o
boolean isEmpty()检测set是否为空，空返回true，否则返回false
void clear()清空集合
int size()返回set中元素的个数
import java.util.*;  
  
public class Test {  
    public static void main(String[] args) {  
        Set<String> treeSet = new TreeSet<>();  
  
        //add（Key）添加元素  
        System.out.println("-----add(Key).....");  
        treeSet.add("张三");  
        treeSet.add("李四");  
        treeSet.add("王五");  
        treeSet.add("钱七");  
  
        //remove(Key)删除元素 "张三"  
        System.out.println("-----remove(Key).....");  
        treeSet.remove("张三");  
  
        //是否包含元素 "钱七"  
        System.out.println("-----contains(Key).....");  
        boolean isContain = treeSet.contains("钱七");  
        System.out.println("是否包含元素钱七: " + isContain);  
  
        //集合是否为null  
        System.out.println("-----isEmpty().....");  
        boolean empty = treeSet.isEmpty();  
        System.out.println("集合是否为空: " + empty);  
  
        //得到集合元素个数  
        System.out.println("-----size().....");  
        int size = treeSet.size();  
        System.out.println("元素个数: " + size);  
  
        //迭代器遍历得到Set集合内容  
        System.out.println("-----iterator().....");  
        System.out.print("集合里面的元素:");  
        Iterator<String> iterator = treeSet.iterator();  
        while (iterator.hasNext()) {  
            System.out.print(iterator.next() + " ");  
        }  
        System.out.println();  
  
        //删除所有元素  
        System.out.println("-----clear().....");  
        treeSet.clear();  
    }  
}

执行结果如下：
在这里插入图片描述

前面我们提到Set是天然去重的，也就是说我们可以利用Set来完成我们的去重操作，例如：当一个序列中数据为：{1 , 1 , 1, 23 ,77 , 2 , 92 ,77},对于一个TreeSet集合，把每个元素添加到Set集合就可以完成去重操作。

import java.util.*;  
  
public class Test {  
    public static void main(String[] args) {  
        int arr[] = {1 , 1 , 1, 23 ,77 , 2 , 92 ,77};  
        Set<Integer> treeSet = new TreeSet<>();  
  
        //去重前打印  
        System.out.println("去重前:");  
        for (int val : arr) {  
            System.out.print(val + " ");  
        }  
        System.out.println();  
  
  
        //去重  
        for (int val : arr) {  
            treeSet.add(val);  
        }  
  
        //去重后, 打印  
        System.out.println("去重后:");  
        for (int val : treeSet) {  
            System.out.print(val + " ");  
        }  
        System.out.println();  
    }  
}

运行结果如下：
在这里插入图片描述

2.4 总结

  • Set是继承自Collection的一个接口类
  • Set中只存储了key，并且要求key一定要唯一
  • TreeSet的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的
  • Map中存放键值对的Key是唯一的，value是可以重复的
  • TreeMap和TreeSet的底层数据结构是红黑树，所以插入的元素都必须是能够比较大小的
学编程的小鬼
关注
专栏目录
【数据结构】TreeMap和TreeSet
拼命阿紫冲冲冲！
03-20 1320
本期主要讲解：1、TreeMap 1.1 TreeMap 的简介 1.2 TreeMap 的基本使用 2、TreeSet 2.1 TreeSet 的简介 2.2 TreeSet 的基本操作
TreeMap和TreeSet在排序时如何比较元素？Collections工具类中的sort()方法如何比较元素？
LiQiyao的博客
09-01 2145
TreeMap和TreeSet都是有序的集合。 TreeSet要求集合中的元素实现Comparable接口，并实现compareTo方法进行比较，如果compareTo方法实现的不好，可能会导致元素插入失败，因为集合内部也通过compareTo方法来比较元素是否相等（而不是通过equals），即判断一个元素是否可插入。 TreeMap要求键列的元素实现Comparable接口，与TreeSet
Java提高篇（二七）-----TreeMap
weixin_30580943的博客
05-23 2071
原文出自：http://cmsblogs.com/?p=1013。尊重作者的成果，转载请注明出处！ 个人站点：http://cmsblogs.com------------------------------------------------------------------------------------------------------------...
TreeMap 排序
weixin_33868027的博客
10-30 1209
一、TreeMap TreeMap 默认排序规则：按照key的字典顺序来排序（升序） 当然，也可以自定义排序规则：要实现Comparator接口。 用法简单，先看下下面的demo public class SortDemo { public static void main(String[] args) { System.out.println("---...
TreeSet和TreeMap
ABidMan的博客
11-06 304
TreeSet和TreeMap 一、TreeSet调试用例 package com.liu.collection; import java.util.TreeSet; public class TreeSet_ { public static void main(String[] args) { //treeset底层是treemap // comparator 用于维护此树映射中的顺序的比较器，或 // 如果使用其键的自然顺序，则为null。
java中treemap和treeset实现红黑树
08-28
Java 中 TreeMap 和 TreeSet 实现红黑树 Java 中的 TreeMap 和 TreeSet 都是基于红黑树的数据结构实现的。红黑树是一种自平衡的排序二叉树，它可以保证在插入、删除和搜索操作时都能维持平衡，从而确保搜索、插入...
Java中AVL平衡二叉树实现Map_(仿照TreeMap和TreeSet)1
08-08
"Java中AVL平衡二叉树实现Map_(仿照TreeMap和TreeSet)1" 本文将详细介绍Java中AVL平衡二叉树实现Map的知识点，以便读者更好地理解和应用AVL树在Java中的实现。 一、AVL树的概念和特点 AVL树是一种自平衡二叉搜索...
treemap和treeset的区别java
09-06
treemap和treeset都是Java中的集合类，但它们的区别在于： 1. treemap是基于红黑树实现的，而treeset也是基于红黑树实现的，但是它是将元素作为key存储的。 2. treemap是一个键值对集合，它可以根据key进行排序，...
TreeSet和treemap
weixin_52370850的博客
01-28 212
treemap相当于在treeset的基础上增加了key到value的映射。 treeset会对元素进行排序，有排序就可以获得第一个比X元素大或者最后一个比X元素小的元素。
剖析 TreeMap 和 TreeSet
sinat_41653656的博客
11-16 705
剖析 TreeMap 和 TreeSet前言1. 剖析 TreeMap1.1 TreeMap1.2 实现原理1.2.1 内部组成1.2.2 构造方法1.2.3 保存键值对1.2.4 根据键获取值1.2.5 查看是否包含某个值1.2.6 根据键删除键值对1.3 总结 前言 1. 剖析 TreeMap 1.1 TreeMap TreeMap 首先继承了 AbstractMap 抽象类，表示它具有散列表的性质，也就是由 key-value 组成。其次 TreeMap 实现了 Naviga
Java 【数据结构】 TreeSet&TreeMap（二叉搜索树详解）【神装】
最新发布
2302_79806056的博客
05-08 5088
每个节点都有一个键（Key）和两个指向其他节点的指针（左子指针和右子指针）。任意节点的左子树中的所有键都小于该节点的键。任意节点的右子树中的所有键都大于该节点的键。左右子树也都是二叉搜索树。不存在键值相等的节点。int val;Node left;Node right;// 构造函数、插入方法、查找方法、删除方法等...TreeSet是Java集合框架中的一种有序集合，它实现了Set接口，因此具有不允许重复元素的特性。
TreeSet与TreeMap
silently_frog的博客
01-16 261
TreeSet与TreeMap   TreeSet: 1.TreeSet优点可以初系统自己的排序外，还可以自定义排序;(Comparable与Comparator) 2.在添加数据时排序； 3.缺点：添加了的数据不能更改；（因为2，所以在你改变了数据后，数据顺序亦不会在改变） 4.具有Tree的特性：排序，Set的特性：数据不能重复； 5.一般我们把数据
treeMap与treeSet
雾幻的博客
10-23 371
为了理解 TreeMap 的底层实现，必须先介绍排序二叉树和红黑树这两种数据结构。其中红黑树又是一种特殊的排序二叉树。 排序二叉树 排序二叉树是一种特殊结构的二叉树，可以非常方便地对树中所有节点进行排序和检索。 排序二叉树要么是一棵空二叉树，要么是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值...
TreeMap与TreeSet（初步了解）
c_study__c的博客
10-20 1780
TreeMap与TreeSet（初）
TreeSet和treeMap
云想衣裳花想容，春风拂槛露华浓
08-28 702
treeSet是一个有序的集合，可以以任意顺序将元素插入到集合中，对集合进行遍历时，每个值将自动的按照排序后的顺序呈现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值