class 026 哈希表、有序表和比较器的用法

于 2024-09-27 20:38:42 发布
阅读量191 收藏 2
点赞数 6
分类专栏： 左程云老师的算法通关课 文章标签： 数据结构 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80967814/article/details/142601972
版权

这篇文章是看了“左程云”老师在b站上的讲解之后写的, 自己感觉已经能理解了, 所以就将整个过程写下来了。

这个是“左程云”老师个人空间的b站的链接, 数据结构与算法讲的很好很好, 希望大家可以多多支持左程云老师, 真心推荐.
https://space.bilibili.com/8888480?spm_id_from=333.999.0.0

在这里插入图片描述

1. 哈希表

注意：我们这一节课只是讲述用法, 不是讲述底层的实现原理, 请大家不要误会.

可以将哈希表想象成一个集合.

1.1 Hashset 类

例子：这个类就是一个集合, 将所有你自己想要加入的数字放进去, 比如：3, 5, 6, 7, 这些都是 key, 然后这些数字都会放到这个集合中, 实现增, 删, 改, 查, 等操作的时间复杂度是：O(1), 常数时间. 但是需要注意的是：这个常数时间是一个大常数时间.

在这里插入图片描述

1.2 HashMap 类

和 HashSet 基本上是一样的, 只是多了一个 value, 例子：比如将字符 A 存储到集合中, 那 A 对应的 Key 是 3(假设), 将字符 B 存储到集合中, 那 B 对应的 Key 是 3722(假设). 就是这样的一个对应的关系. 和 HashSet 区别只是多了一个伴随数据. 而且 HashSet 是将 Key 和 value 同时存储在集合中的. 时间复杂度也是一样：O(1).

在这里插入图片描述

1.3 代码实例

代码中对应的解释我都写到了注释当中.

public static void main(String[] args) {  
    // Integer、Long、Double、Float  
    // Byte、Short、Character、Boolean  
    // String等都有这个特征  
    String str1 = new String("Hello");  
    String str2 = new String("Hello");  
    // false，因为不同的内存地址  
    System.out.println(str1 == str2);  // 上面所说的类中, 都是比较的内存地址.
    // true，因为它们的值是相同的  
    System.out.println(str1.equals(str2));  // 需要使用.equals().这个都是在开始学习Java的时候就注意的坑了.
  
    HashSet<String> set = new HashSet<>(); // 创建了hashSet  
    set.add(str1);                         // 将“Hello”加入了进去, 对于hashSet来说, 只关心集合中有没有这个值,  
    System.out.println(set.contains("Hello"));  
    System.out.println(set.contains(str2));  // 这个返回的结果是：true, 因为在集合中, 已经有了Hello了(只关心值).  
    set.add(str2);             // 因为str1 和 str2 是一样的, 所以这个str2相当于在集合中已经存在了, 所以相当于没有将str2加入到集合中  
    System.out.println(set.size());  // 这里打印出来的值还是“1”.  
    set.remove(str1);          // 移除“str1”的Key  
    set.clear();               // 将集合中所有的Key都清空  
    System.out.println(set.isEmpty());  // 判断集合中是否为“空”.  
  
	System.out.println("===========");  
	  
	HashMap<String, String> map1 = new HashMap<>();  
	map1.put(str1, "World");                // 放进去一个Key：str1, 一个value：World.  
	System.out.println(map1.containsKey("Hello")); // 判断其中有没有一个“Hello” 的key. 返回true  
	System.out.println(map1.containsKey(str2));    // 还是返回true, 和HashSet一样是只根据字面值判断.  
	System.out.println(map1.get(str2));       // 通过Key的值, 找到“World”并进行打印.  
	System.out.println(map1.get("你好") == null); // 想要在集合中拿到一个不存在的值会返回null.  
	map1.remove("Hello");  
	System.out.println(map1.size());  
	map1.clear();  
	System.out.println(map1.isEmpty());  
	//当存储的类型是上述八种类型的时候, 是根据字面值来进行判断的.
  
    System.out.println("===========");  
  
    // 一般在笔试中，未必需要申请哈希表  
    HashMap<Integer, Integer> map2 = new HashMap<>();  
    map2.put(56, 7285);  
    map2.put(34, 3671263);  
    map2.put(17, 716311);  
    map2.put(24, 1263161);  
    // 上面的map2行为，可以被如下数组的行为替代  
    int[] arr = new int[100];  
    arr[56] = 7285;  
    arr[34] = 3671263;  
    arr[17] = 716311;  
    arr[24] = 1263161;  
    // 哈希表的增、删、改、查，都可以被数组替代，前提是key的范围是固定的、可控的  
    System.out.println("在笔试场合中哈希表往往会被数组替代");  
  
    System.out.println("===========");  
    Student s1 = new Student(17, "张三");  
    Student s2 = new Student(17, "张三");  
    HashMap<Student, String> map3 = new HashMap<>();  
    map3.put(s1, "这是张三");  
    System.out.println(map3.containsKey(s1));  
    System.out.println(map3.containsKey(s2));  
    map3.put(s2, "这是另一个张三");  
    System.out.println(map3.size());  
    System.out.println(map3.get(s1));  
    System.out.println(map3.get(s2));  
}  
  
public static class Student {  
    public int age;  
    public String name;  
  
    public Student(int a, String b) {  
       age = a;  
       name = b;  
    }  
}

最后总结一下：

  1. Integer、Long、Double、Float Byte、Short、Character、Boolean String 等都是使用字面值判断Key.
  2. 除此之外的类都是使用内存地址做 Key.

2. 有序表

在这里插入图片描述

有序表的增删改查操作的时间复杂度是：O(log(n)). 而且在传入对象的时候, 会自动进行排序.

2.1 代码实例

public static void main(String[] args) {  
    // 底层红黑树  
    TreeMap<Integer, String> treeMap = new TreeMap<>();  
    treeMap.put(5, "这是5");  
    treeMap.put(7, "这是7");  
    treeMap.put(1, "这是1");  
    treeMap.put(2, "这是2");  
    treeMap.put(3, "这是3");  
    treeMap.put(4, "这是4");  
    treeMap.put(8, "这是8");  
  
	System.out.println(treeMap.containsKey(1));    // 判断有序表中包不包含存在不存在key值为“1”  
	System.out.println(treeMap.containsKey(10));  
	System.out.println(treeMap.get(4));           // 打印Key值为“4”对应的值.  
	treeMap.put(4, "张三是4");                     // 进行修改更新  
	System.out.println(treeMap.get(4));           // 重新打印, 会更新为新的值  
	  
	treeMap.remove(4);                        // 移除Key值为“4”的值.  
	System.out.println(treeMap.get(4) == null);     
	  
	// 下面这四行功能就是哈希表做不到的事情.  
	System.out.println(treeMap.firstKey());  // 寻找key值最小的key.
	System.out.println(treeMap.lastKey());   // 寻找key值最大的key.
	// TreeMap中，所有的key，<= 4且最近的key是什么  
	System.out.println(treeMap.floorKey(4));  
	// TreeMap中，所有的key，>= 4且最近的key是什么  
	System.out.println(treeMap.ceilingKey(4));  
	  
	System.out.println("========");
  
    TreeSet<Integer> set = new TreeSet<>();  
    set.add(3);  
    set.add(3);  
    set.add(4);  
    set.add(4);  
    System.out.println("有序表大小 : " + set.size());  
    while (!set.isEmpty()) {  
       System.out.println(set.pollFirst());  
       // System.out.println(set.pollLast());  
    }  
  
    // 堆，默认小根堆、如果要大根堆，定制比较器！  
    PriorityQueue<Integer> heap1 = new PriorityQueue<>();  
    heap1.add(3);  
    heap1.add(3);  
    heap1.add(4);  
    heap1.add(4);  
    System.out.println("堆大小 : " + heap1.size());  
    while (!heap1.isEmpty()) {  
       System.out.println(heap1.poll());  
    }  
  
    // 定制的大根堆，用比较器！  
    PriorityQueue<Integer> heap2 = new PriorityQueue<>((a, b) -> b - a);  
    heap2.add(3);  
    heap2.add(3);  
    heap2.add(4);  
    heap2.add(4);  
    System.out.println("堆大小 : " + heap2.size());  
    while (!heap2.isEmpty()) {  
       System.out.println(heap2.poll());  
    }  
  
}

3. 比较器

3.1 代码实例

public static class Employee {  
    public int company;  
    public int age;  
  
    public Employee(int c, int a) {  
       company = c;  
       age = a;  
    }  
}  
  
public static class EmployeeComparator implements Comparator<Employee> {  
  
    @Override  
    public int compare(Employee o1, Employee o2) {  
//       if(o1.age < o2.age) {
//           return -1;
//       } else if (o1.age > o2.age) {
//           return 1;                   // 这段代码可以实现谁年龄小, 谁优先级高.
//       } else {
//           return 0;
//       }
	   // 上面这段代码可以简化为下面这句代码.
	   // 这个比较的意义是：谁优先级高谁在前面.
       // 任何比较器都默认  
       // 如果返回负数认为o1的优先级更高  
       // 如果返回正数认为o2的优先级更高  
       // 任何比较器都是这样，所以利用这个设定，可以定制优先级怎么确定，也就是怎么比较  
       // 不再有大小的概念，就是优先级的概念  
       return o1.age - o2.age;  
    }  
  
}  
  
public static void main(String[] args) {  
    Employee s1 = new Employee(2, 27);  
    Employee s2 = new Employee(1, 60);  
    Employee s3 = new Employee(4, 19);  
    Employee s4 = new Employee(3, 23);  
    Employee s5 = new Employee(1, 35);  
    Employee s6 = new Employee(3, 55);  
    Employee[] arr = { s1, s2, s3, s4, s5, s6 };  
    Arrays.sort(arr, new EmployeeComparator());    // 按照上述比较器的方式进行排序.
    for (Employee e : arr) {  
       System.out.println(e.company + " , " + e.age);  
    }  
  
    System.out.println("=====");  
  
    Arrays.sort(arr, (a, b) -> b.age - a.age);    // 使用lambad表达式.可以进行简化, 这个遵循的还是谁大谁在前面.
    for (Employee e : arr) {  
       System.out.println(e.company + " , " + e.age);  
    }  
  
    System.out.println("=====");  
    // 所有员工，先按照谁的公司编号小，谁在前；如果公司编号一样，谁年龄小谁在前  
    Arrays.sort(arr, (a, b) -> a.company != b.company ? (a.company - b.company) : (a.age - b.age));  
    for (Employee e : arr) {  
       System.out.println(e.company + " , " + e.age);  
    }  
	// 一定要将比较方法放到这个里面. 因为我们实现的是自己实现的员工类型
    TreeSet<Employee> treeSet1 = new TreeSet<>(new EmployeeComparator());  
    for (Employee e : arr) {  
       treeSet1.add(e);  
    }  
    System.out.println(treeSet1.size());  
  
    // 会去重  
    treeSet1.add(new Employee(2, 27));  
    System.out.println(treeSet1.size());  
  
    System.out.println("===");  
  
    // 如果不想去重，就需要增加更多的比较  
    // 比如对象的内存地址、或者如果对象有数组下标之类的独特信息  
    TreeSet<Employee> treeSet2 = new TreeSet<>((a, b) -> a.company != b.company ? (a.company - b.company)  
          : a.age != b.age ? (a.age - b.age) : a.toString().compareTo(b.toString()));  
    for (Employee e : arr) {  
       treeSet2.add(e);  
    }  
    System.out.println(treeSet2.size());  
  
    // 不会去重  (堆是不进行去重的)
    treeSet2.add(new Employee(2, 27));  
    System.out.println(treeSet2.size());  
  
    System.out.println("===");  
  
    // PriorityQueue不会去重，不再展示了  
}

4. 字典序

先举两个例子：

  1. 两个字符串长度一样的时候： "ab"和"cd" 比较大小, 因为 c > a, 所以 "cd" > "ab". a, b, c, d 都可以认为是一个 26 进制的, 可以进行比较, 要是有什么 *, %, #, @ 也可以认为是一个 256 进制的. 都可以进行比较.
  2. 两个字符串长度不一样的时候："abcd"和"ck", 因为是和"字典"一样的, 所以肯定还是 "abcd" > "ck", 但是我们需要用数学的方式进行定义, 所以直接将短的那一个字符串补到和长的字符串一样长, 这个时候再进行比较, 并且要用 0(不是字符0, 是进制中最小的) 来补.
// 字典序  
String str1 = "abcde";  
String str2 = "ks";  
System.out.println(str1.compareTo(str2));  
// 可以认为str1是前, str2是后, 然后进行比较, 让前面的 - 后面的.  
System.out.println(str2.compareTo(str1));  
// 可以认为str2是前, str1是后, 然后进行比较, 让后面的 - 前面的.
哎呀呀嗯呀呀
关注
专栏目录
哈希表总结点睛
linping_的博客
04-23 949
哈希表 又称 散列表、 Hash table。哈希表就是根据关键吗的值而直接进校访问的数据结构 其实数组就是一张哈希表，数组的索引为key，数组的元素为value。 数据规模是dataSize， 哈希表的大小为tableSize 哈希表能解决什么问题呢？ 一般是用来快速判断一个元素是否出现集合里。 哈希碰撞有两种解决办法： 1、拉链法：拉链法就是要选择适当的哈希表的大小，这样既不会因为数组空值而浪费大量内存，也不会因为链表太长而在查找上浪费太多时间。 2、线性探测法：使用线性探测法，一定要保证tab
哈希表和有序表的简单使用
niceYF的博客
03-07 152
哈希表有两种形式 HashSet和HashMap HashSet只有key，HashMap中有key和value。结构都是一样的，没有区别。 public static void main(String[] args) { HashSet<Integer> hashSet1 = new HashSet<>(); hashSet1.add(2); System.out.println(hashSet1.contains(2)); hashS
哈希表、有序表以及比较器的用法-左程云
weixin_74238318的博客
07-19 454
根堆：（优先级队列，默认是小根堆，可以自定义比较器成大根堆）基本的treemap和treeset的使用。
【Java】哈希表 VS 有序表
明朗晨光的专栏
05-05 1109
哈希表和有序表
哈希表C++哈希表详解（知识点+相关LeetCode题目）
qq_60831089的博客
07-21 4880
本文将从哈希表的概念、复杂度、STL实现函数、哈希表相关经典题目展开叙述。哈希表是散列表，就是通过关键码值而直接进行访问的一种数据结构哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素其内部由一个个key：value 样式的键值对组成。哈希表中的key通过哈希函数得到内存地址，然后将key和value放到对应的内存地址，从而实现通过key获取Value的方式哈希碰撞：2个不同的key通过哈希函数
哈希表、有序表、单链表
weixin_44465904的博客
02-12 1216
哈希表、有序表、单链表
哈希表总结
qq_54773998的博客
11-30 1989
目录 引言 一，哈希表概念 1.概念 2.初次简单模拟 3.模拟总结 二，哈希冲突（哈希碰撞） 1.概念 2.分析 初步分析： 避免冲突时的哈希函数设计： 常见的哈希函数： 3.解决 1.闭散列 2.开散列 三，模拟实现哈希桶（开散列） 模拟实现的准备工作 1.定义哈希表中的结点 2.构造方法 3.哈希地址的计算方法 1.操作之添加 / 插入 2.操作之获取key的value 3.操作 之key存在返回key对应的value，key不存在返回默认值 4.操...
【C++】哈希表
m0_74808907的博客
06-30 2067
一文带你由浅入深掌握哈希表
【JavaLearn】 # （10）集合、List、栈、队列、Set、外部比较器、哈希表
LRcoding
08-08 2277
1. 引入集合 1.1 集合的使用场合 需要将一些相同结构的个体整合在一起时，可以使用集合。 1.2 集合和数组的区别 相同：都可以存储多个对象（集合的元素，必须是对象类型，不能是基本类型），对外作为一个整体存在 不同： 数组长度必须在初始化时指定，且固定不变 数组存储时采用连续的空间，删除和添加效率低下 数组无法直接保存映射关系 数组缺乏封装，操作繁琐 1.3 集合框架 Java 提供了一套使用方便、性能优良的接口和类，位于 java.util 包中 集合架构： Collection 接口
C++ 哈希表
热门推荐
weixin_40535588的博客
11-24 3万+
什么是哈希表 map、hash_map、unordered_map的引入 unordered_map的用法 1. 什么是哈希表 1.1 哈希表的定义 “散列表（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。 从上面的百度百科，我们小白可以知道3点： 哈希表也叫散列表 哈希表是一个数据结构 散列表是数组.
C#中哈希表(HashTable)用法实例详解(添加/移除/判断/遍历/排序等)
09-02
3. **哈希表的使用方法** 使用哈希表前，需要导入`System.Collections`命名空间。以下是一些基本操作： - **添加键值对**：`ht.Add(key, value);` - **移除键值对**：`ht.Remove(key);` - **清空所有元素**：`ht...
左神算法基础5-链表——哈希表、有序表、单链表和双链表
qq_41924554的博客
08-16 809
题目7反转单向和双向链表题目1：反转单向链表1.分析（1）单向链表节点结构2.核心代码3.完整代码4.输出结果题目2：反转双向链表1.分析2.核心代码3.完整代码4.输出结果 题目1：反转单向链表 1.分析 （1）单向链表节点结构 public class Node{ public int value; public Node next; public Node(int data){ value = data;
C++实现哈希表。
TPON的博客
11-17 6597
C++模拟实现哈希表
【数据结构】什么是二叉搜索(排序)树?
C/C++领域,数据结构,linux,MySQl学习者
09-20 1337
数据结构之二叉搜索树概念详解,内容包括:二叉搜索树的概念,二叉搜索树的操作(查找,插入,删除)逻辑详解及图示,二叉搜索树的应用以及二叉搜索树的性能分析。
【数据结构取经之路】图解红黑树
bit_pan的博客
09-20 856
AVL-tree之外，另一个颇具历史且被广泛使用的平衡二叉搜索树是红黑树(RB-tree)，这名字听起来除了很抽象外，还颇具大哥味哈，会不会很难？客观地说，难度是有的，下面我们细细道来。//结点的颜色//红黑树结点的定义//结点的左孩子//结点的右孩子//结点的父节点//结点的颜色T _data;//结点的数据域{}以上就是红黑树节点定义，但有两个问题：为什么需要指向父节点的指针？为什么要将结点的默认颜色设置成黑色？先来回答第一个问题，在旋转时需要访问父节点，所以引入了指向父节点的指针。
数据结构之——单链表
最新发布
m0_71974552的博客
09-23 1111
深入了解单链表：数据结构中的灵活利器
数据结构应试-树和二叉树
Nozomi9967的博客
09-20 476
树内各结点度的最大值，即上图 D 结点的度就是此树的度叶子：度为 0 的节点称为叶子或终端节点结点的层次和树的深度。
数据结构—(java)反射，枚举，lambda表达式
2301_77993957的博客
09-20 1098
java的反射机制是指，在程序的运行状态中，对于任意一个类，可以获取这个类的全部信息（包括，类加载器（后面会学到），构造方法，成员属性，成员方法等。对于任意一个对象，我们也能够调用其属性与方法进行修改信息，这种动态地获取信息与动态地调用对象的机制，我们称为反射机制。
每日学习一个数据结构-Trie树(字典树)
wendao76的专栏
09-23 606
Trie 树是一种有序树，用于存储字符串，其中每个节点都代表输入字符串的一个字符。从根节点到任意一个叶子节点的路径上所包含的字符序列构成了一个字符串。
hashmap和treemap区别
04-15
HashMap和TreeMap是Java中两种常用的Map实现类，它们之间有以下区别[^1][^2]： 1. 排序性能：TreeMap是有序的，而HashMap是无序的。TreeMap实现了SortedMap接口，可以根据键的自然顺序或自定义比较器进行排序。而HashMap则没有排序功能。 2. 时间复杂度：HashMap的基本操作（如get()和put()）具有O(1)的恒定时间复杂度，而TreeMap的基本操作具有O(log n)的时间复杂度。这是因为HashMap使用哈希表实现，而TreeMap使用红黑树实现。 3. 迭代顺序：TreeMap的迭代顺序是按照键的顺序进行的，而HashMap的迭代顺序是不确定的，取决于哈希表的存储情况。 4. 空间占用：TreeMap的空间占用比HashMap更大，因为TreeMap需要额外存储红黑树的结构。 5. 线程安全性：HashMap是非线程安全的，而TreeMap可以通过Collections.synchronizedSortedMap()方法进行同步，使其成为线程安全的。 6. 适用场景：由于HashMap具有更好的性能和较低的空间占用，通常在大多数情况下优先选择HashMap。而TreeMap适用于需要有序存储键值对的场景。 下面是一个示例，演示了HashMap和TreeMap的区别： ```java import java.util.HashMap; import java.util.TreeMap; public class MapExample { public static void main(String[] args) { // 使用HashMap HashMap<String, Integer> hashMap = new HashMap<>(); hashMap.put("apple", 3); hashMap.put("banana", 2); hashMap.put("orange", 5); System.out.println("HashMap: " + hashMap); // 使用TreeMap TreeMap<String, Integer> treeMap = new TreeMap<>(); treeMap.put("apple", 3); treeMap.put("banana", 2); treeMap.put("orange", 5); System.out.println("TreeMap: " + treeMap); } } ``` 输出结果： ``` HashMap: {orange=5, banana=2, apple=3} TreeMap: {apple=3, banana=2, orange=5} ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值