集合(Set)和映射(Map)基础总结

最新推荐文章于 2022-08-08 16:27:14 发布
最新推荐文章于 2022-08-08 16:27:14 发布
阅读量714 收藏
点赞数
分类专栏： 算法 文章标签： SetMap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxzxzx0119/article/details/79891408
版权

集合(Set)和映射(Map)基础总结

  • Set介绍
  • 基于链表实现Set
  • 基于二叉搜索树实现Set
  • 基于二叉平衡树实现Set
  • 使用Set解决LeetCode-804. Unique Morse Code Words
  • 使用Set解决LeetCode-349. Intersection of Two Arrays
  • Map介绍
  • 基于链表实现Map
  • 基于二叉搜索树实现Map
  • 基于二叉平衡树实现Map
  • 使用Map解决LeetCode-350. Intersection of Two Arrays II
  • Set和Map的一些对比和总结

Set介绍

  • Set是不允许重复的集合容器；
  • Set可以分为有序集合和无需集合；
  • 有序集合基于搜索树实现，JDK底层是红黑树，即TreeSet；
  • 无序集合基于Hash表实现，JDK底层是HashMap包装之后，即HashSet；

基于链表实现Set

首先看一下单链表的实现，下面的实现中使用SingleList实现:
先看Set接口中需要实现的方法:

/**
 * Set接口
 * @param <E>
 */
public interface Set<E> {
    void add(E e);
    boolean contains(E e);
    void remove(E e);
    int getSize();
    boolean isEmpty();
}

如果有单链表的相关方法，其中的Set就很容易实现，唯一要注意的就是 在添加元素的时候要注意先判断集合中有没有这个元素:

/**
 * 基于单链表实现 Set
 * @param <E>
 */
public class LinkedListSet<E> implements Set<E> {

    private SingleList<E> list;

    public LinkedListSet(){
        list = new SingleList<>();
    }

    @Override
    public int getSize(){
        return list.size();
    }

    @Override
    public boolean isEmpty(){
        return list.isEmpty();
    }

    @Override
    public void add(E e){
        if(!list.contains(e)) //这个就是效率低的原因
            list.addFirst(e);
    }

    @Override
    public boolean contains(E e){
        return list.contains(e);
    }

    @Override
    public void remove(E e){
        list.removeElement(e);
    }

}

基于二叉搜索树实现Set

先看一下二叉搜索树相关方法的实现。注意由于我实现的二叉搜索树没有重复元素，所有Set也没有重复元素。

/**
 * 基于二叉搜索树实现的Set  类似JDK的TreeSet (有序集合)   而HashSet是无序集合
 * @param <E>
 */
public class BSTSet<E extends Comparable<E>> implements Set<E> {

    private BSTree<E> bst;

    public BSTSet(){
        bst = new BSTree<>();
    }

    @Override
    public int getSize(){
        return bst.size();
    }

    @Override
    public boolean isEmpty(){
        return bst.isEmpty();
    }

    @Override
    public void add(E e){
        bst.add(e);
    }

    @Override
    public boolean contains(E e){
        return bst.contains(e);
    }

    @Override
    public void remove(E e){
        bst.remove(e);
    }
}

基于二叉平衡树实现Set

在这之前先看一下二叉平衡树的总结和代码实现。

public class AVLSet<E extends Comparable<E>> implements Set<E> {

    private AVLTree<E, Object> avl;

    public AVLSet(){
        avl = new AVLTree<>();
    }

    @Override
    public int getSize(){
        return avl.size();
    }

    @Override
    public boolean isEmpty(){
        return avl.isEmpty();
    }

    @Override
    public void add(E e){
        avl.add(e, null);
    }

    @Override
    public boolean contains(E e){
        return avl.contains(e);
    }

    @Override
    public void remove(E e){
        avl.remove(e);
    }
}

使用Set解决LeetCode-804. Unique Morse Code Words

题目链接

在这里插入图片描述
很简单的题目，转换成对应的解码，然后存到一个不能重复的set集合中，返回集合中的元素个数即可；

   public int uniqueMorseRepresentations(String[] words) {
        if (words == null || words.length == 0) {
            return 0;
        }
        String[] dict = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};
        HashSet<String>set = new HashSet<>();
        for(String word : words){
            StringBuilder sb = new StringBuilder();
            for(int i = 0; i < word.length(); i++){
                sb.append(dict[word.charAt(i) - 'a']);
            } 
            set.add(sb.toString());
        }
        return set.size();
    }

使用Set解决LeetCode-349. Intersection of Two Arrays

题目链接

在这里插入图片描述
解题思路: 我们可以使用一个set一开始去除nums1中的重复元素，遍历nums2中的元素，判断每个元素在nums1中是否出现，为了不重复，记录一个之后要在set中删除这个。

   public int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer>set = new HashSet<>();
        for(int num : nums1) set.add(num);
        
        ArrayList<Integer>list = new ArrayList<>();
        for(int num : nums2) {
            if(set.contains(num)){
                list.add(num);
                set.remove(num);// important
            }
        }
        int[] res = new int[list.size()];
        for(int i = 0 ; i < list.size() ; i ++)
            res[i] = list.get(i);
        return res;
    }

另外这个题目基于双指针和二分Ologn的实现也不难，可以看下这里。

Map介绍

  • Map的键不允许重复，如果重复插入键相同的，则新的value覆盖原来的value；
  • Map可以分为有序Map和无序Map；
  • 有序Map基于搜索树实现，JDK底层使用红黑树实现，即TreeMap；
  • 无序Map基于Hash表实现，JDK底层使用Hash表底层实现，即HashMap；

基于链表实现Map

和普通的单链表不同的:

  • 结点内部是key,value的键值对；
  • getNode()，返回key对应的结点，方便操作；
  • 在add()操作的时候，如果已经存在key对应的结点，就更新value即可；
public class LinkedListMap<K, V> implements Map<K, V> {

    //结点结构
    private class Node {
        public K key;
        public V value;
        public Node next;

        public Node(K key, V value, Node next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public Node(K key, V value) {
            this(key, value, null);
        }

        public Node() {
            this(null, null, null);
        }

        @Override
        public String toString() {
            return key.toString() + " : " + value.toString();
        }
    }

    private Node dummyHead;
    private int size;

    public LinkedListMap() {
        dummyHead = new Node();
        size = 0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    
    // important
    private Node getNode(K key) {
        Node cur = dummyHead.next;
        while (cur != null) {
            if (cur.key.equals(key))
                return cur;
            cur = cur.next;
        }
        return null;
    }

    @Override
    public boolean contains(K key) {
        return getNode(key) != null;
    }

    @Override
    public V get(K key) {
        Node node = getNode(key);
        return node == null ? null : node.value;
    }

    @Override
    public void add(K key, V value) {
        Node node = getNode(key);
        if (node == null) {
            /**Node newNode = new Node(key,value);
            newNode.next = dummyHead.next;
            dummyHead.next = newNode;*/
            dummyHead.next = new Node(key, value, dummyHead.next);// == 上面三行
            size++;
        } else //already exist
            node.value = value;
    }

    @Override
    public void set(K key, V newValue) {
        Node node = getNode(key);
        if (node == null)
            throw new IllegalArgumentException(key + " doesn't exist!");

        node.value = newValue;
    }

    @Override
    public V remove(K key) {

        Node prev = dummyHead;
        while (prev.next != null) {
            if (prev.next.key.equals(key))
                break;
            prev = prev.next;
        }

        if (prev.next != null) {
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size--;
            return delNode.value;
        }

        return null;
    }
}

基于二叉搜索树实现Map

和二叉搜索树中的操作差不多，注意:

  • 在添加的时候，如果已经存在，也就是key相等的话就直接更新value即可；
  • 增加getNode()方法: 返回以node为根节点的二分搜索树中，key所在的节点；
  • 大部分对于e(也就是结点值)的操作，就是对key的操作；
public class BSTMap<K extends Comparable<K>, V> implements Map<K, V> {

    private class Node {
        public K key;
        public V value;
        public Node left, right;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BSTMap() {
        root = null;
        size = 0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    // 向二分搜索树中添加新的元素(key, value)
    @Override
    public void add(K key, V value) {//相当于JDK的put操作
        root = add(root, key, value);
    }

    // 向以node为根的二分搜索树中插入元素(key, value)，递归算法
    // 返回插入新节点后二分搜索树的根
    private Node add(Node node, K key, V value) {

        if (node == null) {
            size++;
            return new Node(key, value);
        }

        if (key.compareTo(node.key) < 0)
            node.left = add(node.left, key, value);
        else if (key.compareTo(node.key) > 0)
            node.right = add(node.right, key, value);
        else   // key.compareTo(node.key) == 0
            node.value = value;

        return node;
    }

    // 返回以node为根节点的二分搜索树中，key所在的节点
    private Node getNode(Node node, K key) {

        if (node == null)
            return null;

        if (key.equals(node.key))
            return node;
        else if (key.compareTo(node.key) < 0)
            return getNode(node.left, key);
        else // if(key.compareTo(node.key) > 0)
            return getNode(node.right, key);
    }

    @Override
    public boolean contains(K key) {
        return getNode(root, key) != null;
    }

    @Override
    public V get(K key) {
        Node node = getNode(root, key);
        return node == null ? null : node.value;
    }

    @Override
    public void set(K key, V newValue) {
        Node node = getNode(root, key);
        if (node == null)
            throw new IllegalArgumentException(key + " doesn't exist!");

        node.value = newValue;
    }

    // 返回以node为根的二分搜索树的最小值所在的节点
    private Node minimum(Node node) {
        if (node.left == null)
            return node;
        return minimum(node.left);
    }

    // 删除掉以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMin(Node node) {
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }

    // 从二分搜索树中删除键为key的节点
    @Override
    public V remove(K key) {

        Node node = getNode(root, key);
        if (node != null) {
            root = remove(root, key);
            return node.value;
        }
        return null;
    }

    private Node remove(Node node, K key) {

        if (node == null)
            return null;

        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            return node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            return node;
        } else {   // key.compareTo(node.key) == 0

            // 待删除节点左子树为空的情况
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }

            // 待删除节点右子树为空的情况
            if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }

            /** 待删除节点左右子树均不为空的情况
             找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
             用这个节点顶替待删除节点的位置*/
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;

            node.left = node.right = null;

            return successor;
        }
    }
}

基于二叉平衡树实现Map

在这之前先看平衡二叉树的原理和实现。

public class AVLMap<K extends Comparable<K>, V> implements Map<K, V> {

    private AVLTree<K, V> avl;

    public AVLMap(){
        avl = new AVLTree<>();
    }

    @Override
    public int getSize(){
        return avl.size();
    }

    @Override
    public boolean isEmpty(){
        return avl.isEmpty();
    }

    @Override
    public void add(K key, V value){
        avl.add(key, value);
    }

    @Override
    public boolean contains(K key){
        return avl.contains(key);
    }

    @Override
    public V get(K key){
        return avl.get(key);
    }

    @Override
    public void set(K key, V newValue){
        avl.set(key, newValue);
    }

    @Override
    public V remove(K key){
        return avl.remove(key);
    }
}

使用Map解决LeetCode-350. Intersection of Two Arrays II

题目链接

在这里插入图片描述
解题思路： 也很简单，只需要用map记录一下次数。然后在map中更新维护次数即可。

 public int[] intersect(int[] nums1, int[] nums2) {
        HashMap<Integer,Integer>map = new HashMap<>();
        
        
        for(int num : nums1){
            if(!map.containsKey(num)){
                map.put(num,1);
            }else {
                map.put(num,map.get(num) + 1);
            }
        }
        
        ArrayList<Integer>list = new ArrayList<>();
        for(int num : nums2){
            if(map.containsKey(num)){
                list.add(num);
                map.put(num,map.get(num) - 1);
                if(map.get(num) == 0)map.remove(num);
            }
        }
        
        int[] res = new int[list.size()];
        for(int i = 0; i < list.size(); i++) res[i] = list.get(i);
        return res;
    }

Set和Map的一些对比和总结

  • 集合Set和映射Map有很多的相似之处，实现都可以使用链表和搜索树实现；
  • 其中JDK的HashSet也是HashMap包装之后的，虽然用的是Hash表。
  • 使用搜索树实现的Set和Map平均时间复杂度为Ologn(Ologh)(Olog2n)，但是使用链表是O(n)；
Set< E >Map<K，V>
void add(E)void add(K, V)
void remove(E)V remove(K)
boolean contains(E)boolean contains(K)
int getSize()int getSize()
boolean isEmpty()boolean isEmpty()
V get(K)
void set(K, V)
zxzxin
关注
专栏目录
【Java集合 3】Java映射Map、弱散列映射WeakHashMap
学Java，找哪吒
04-07 2025
Java类库为映射提供了两个通用的实现：HashMap和TreeMap，这两个类都实现了Map接口。散列映射对键进行散列，数映射根据键的顺序将它们组织为一个搜索树。
集合与映射
weixin_56165759的博客
01-11 1929
集合与映射
集合和映射
weixin_48079129的博客
04-16 736
概述 集合是存储不重读元素的容器。 集合分为两大类collection和Map。 Collection又分为list（ArrayList,LInkedList）和set(HashSet,TreeSet)两大类。 linkedSet 是由 链表 实现的，有序 TreeSet是由 二分搜索树 实现的，有序 ，自然排序 HashSet是由 哈希表 实现的，无序 映射是存储数据对的数据结构。（键值对，Key,Value,K_V对），根据key寻找value。 Map就是一种映射，它有由链表实现的Link
Java 映射(Map)和集合(Set) 用法总结
u014509577的博客
05-03 1654
1、定义层面 Map 接口定义映射，存储一组键值对的映射关系。 Set 接口定义集合，存储一组互不相同的元素，该接口继承了 Collection 接口。 2、Map 接口的概念和常用方法 Map 接口存储一组键值对的映射关系，映射中的每个键对应一个值。映射中不能有重复的键，否则会出现一个键对应多个值的情况，这违背了映射的定义。 （1）放置键值对 放置键值对的方法有 put 和 putAll，其中 put 一次放置一个键值对，putAll 一次将另一个映射中的键值对全部添加道当...
集合篇总结——Set和Map接口
Demon_and_Angle_的博客
08-08 209
集合篇总结——Set和Map接口
Java集合定义与用法实例总结【Set、List与Map】
08-27
Java集合定义与用法实例总结【Set、List与Map】 Java集合是Java语言中的一种数据结构，主要用于存储和操作数据。Java集合可以分为三大类：Set、List和Map。这些集合都继承了基类接口Collection，Collection接口定义...
hibernate set 集合映射
03-16
总结来说，`hibernate set 集合映射`是Java开发中处理对象关系的重要手段，它提供了丰富的功能来映射和管理数据库表之间的关联。理解并熟练掌握集合映射，有助于编写出高效、易于维护的Java应用。结合源码分析，我们...
hibernate map 集合映射
03-16
正确配置和使用各种集合类型，如List、Set和Map，可以帮助我们更好地处理数据库中的复杂关系，提高代码的灵活性和可扩展性。同时，关注性能优化策略，如懒加载和批处理，对于大型项目尤为重要。
3 集合与映射
11-29
国防工业大学高数(一)课件。。。。。与国防工业大学出的书配套课件。
java集合与映射（牛）
04-28
java集合与映射 java集合与映射 java集合与映射 java集合与映射 java集合与映射
C++中STL容器的分类和基本功能（二）：集合(set) 映射(map)
一个一般人发现不了的博客
02-03 712
关联容器 特点： 每个关联容器都有一个键(key) 每个元素按键的取值升序排列（对于一个关联容器，使用迭代器s在区间[s.begin(), s.end())内遍历，访问到的序列总是升序） 优势： 可以根据键值高效地查找元素 要求：键值的类型必须能够用 int、double等基本数据类型 其他重载了 例：学生表的存储 class Student{...};
9.集合与映射
EdSheeran的博客
08-02 786
文章目录*集合**9.1Java集合框架**9.1.1集合接口与实现分离**9.1.2`Collection`接口**9.1.3迭代器**9.2集合框架中的接口**9.3具体集合**9.3.1链表**9.3.3散列集**9.3.4树集**9.3.5队列与双端队列**9.3.6优先队列(典型用法是任务调度)**9.4映射**9.4.1基本映射操作**9.4.2更新映射条目**9.4.3映射视图**9.4.4弱散列映射(使用弱引用保存键)**9.4.5链接散列集与映射(记住插入元素项的顺序)**9.4.6枚举集
集合与映射的实现
qq_22230709的博客
08-09 1450
                                                    集合与映射（Map和Set） 1.集合与映射是一种高层的数据结构 我们之前实现了二分搜索树，不能盛放相同元素，是一种非常好的实现“集合”的底层数据结构 由于集合可以使用不同的底层数据结构来实现，我们将我们的set定义为一个接口 因此我们这里使用链表和二分搜索树实现set，并且比较...
第7章 集合和映射
Kaptcha的学习
04-06 334
第7章 集合和映射7-1 集合基础和基于二分搜索树的集合实现7-2 基于链表的集合实现7-3 集合类的复杂度分析7-4 LeetCode中的集合问题7-5 映射基础7-6 基于链表的映射实现7-7 基于二分搜索树的映射实现7-8 映射的复杂度分析7-9 LeetCode上更多集合和映射的问题 7-1 集合基础和基于二分搜索树的集合实现 public interface Set<E> ...
set集合和map集合的区别
最新发布
06-10
1. Set集合是一组无序且不允许重复的元素的集合，而Map集合是一组键值对（key-value）的映射，每个键最多只能映射到一个值。 2. Set集合中的元素是无序的，因此不能通过索引访问元素，而Map集合中的元素是按照键的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值