集合与映射

最新推荐文章于 2025-09-13 14:06:01 发布
原创 最新推荐文章于 2025-09-13 14:06:01 发布 · 821 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
数据结构

当前文章被收录于：

数据结构
23 篇文章 7 人学习
订阅专栏 查看详情
本文探讨了集合和映射这两种数据结构。在集合方面，通过对比基于BST和链表的实现，指出二分搜索树实现的集合在性能上更优。而在映射的实现中，同样发现二分搜索树的效率高于链表。文章分析了两种数据结构在不同情况下的时间复杂度，强调了满二分搜索树时的最佳性能。

一、集合

1、 集合的应用

  • 集合可以用来去重
  • 集合可以用于进行客户的统计
  • 集合可以用于文本词汇量的统计

2、集合的实现

（1）对于集合的一些定义，我们一般也都了解，例如集合一般都不会存放重复的元素，因此这就让它有了去重的功用了。

public interface Set<E> {

    void add(E e);//不能添加重复元素
    boolean contains(E e);
    void remove(E e);
    int getSize();
    boolean isEmpty();

}

（2）集合基于BST的实现

package com.zfy.setandmap;

import com.zfy.bst.BST;

/*
 * 这里是基于之前的二分搜索树实现的，
 * 1.因为集合具有去重的功用，说明它是可以有比较的功能的，所以这里实现了Comparable类，
 * 2.因为集合是可以存各种的数据类型，因此这里设计为泛型
 * */
public class BSTSet<E extends Comparable<E>> implements Set<E> {

    private BST<E> bst;
    
    //所有的BSTSet都是基于BST的
    public BSTSet() {
        bst = new BST<>();
    }
    
    @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);
    }

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

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

（3）用链表作为集合的底层实现

public class LinkedListSet<E> implements Set<E> {

    private LinkedList<E> list;

    // 构造函数
    public LinkedListSet() {
        list = new LinkedList<>();
    }

    // 实现getSize方法
    @Override
    public int getSize() {
        return list.getSize();
    }

    // 实现isEmpty方法
    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    // 实现contains方法
    @Override
    public boolean contains(E e) {
        return list.contains(e);
    }

    // 实现add方法
    @Override
    public void add(E e) {
        if (!list.contains(e)) {
            list.addFirst(e);
        }
    }

    // 实现remove方法
    @Override
    public void remove(E e) {
        list.removeElement(e);
    }

（4）用二分搜索树实现的集合与用链表实现的集合的性能比较

import java.util.ArrayList;

public class Main {

    public static double testSet(Set<String> set, String filename) {

        long startTime = System.nanoTime();

        System.out.println(filename);
        ArrayList<String> words = new ArrayList<>();
        if (FileOperation.readFile(filename, words)) {
            System.out.println("Total words: " + words.size());

            for (String word : words) {
                set.add(word);
            }
            System.out.println("Total different words: " + set.getSize());
        }

        long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        String filename = "pride-and-prejudice.txt";

        BSTSet<String> bstSet = new BSTSet<>();
        double time1 = testSet(bstSet, filename);
        System.out.println("BSTSet, time: " + time1 + " s");

        System.out.println();

        LinkedListSet<String> linkedListSet = new LinkedListSet<>();
        double time2 = testSet(linkedListSet, filename);
        System.out.println("LinkedListSet, time: " + time2 + " s");
    }
}

       输出结果：

pride-and-prejudice.txt
Total words: 125901
Total different words: 6530
BSTSet, time: 0.109504342 s

pride-and-prejudice.txt
Total words: 125901
Total different words: 6530
LinkedListSet, time: 2.208894105 s

        通过比较结果，我们发现，用二分搜索树实现的集合的比用链表实现的集合更加高效。

（5）集合的时间复杂度分析

  • 上图中"h"是二分搜索树的高度
  • 当二分搜索树"满"的时候，性能是最佳的，时间复杂度为O(logn)；当二分搜索树退化为链表的时候，性能是最差的，时间复杂度为O(n

二、映射（Map）

  • 映射是存储（键，值）数据对的数据结构（Key, Value）
  • 根据键（Key），寻找值（Value）

1、定义映射的接口

package com.zfy.setandmap;

public interface Map<K, V> {

    void add(K key, V value);
    V remove(K key);
    boolean contains(K key);
    V get(K key);
    void set(K key, V newValue);
    int getSize();
    boolean isEmpty();

}

2、Map的实现，基于BST的实现

package com.zfy.setandmap;

/*
 * 因为这里是基于二分搜索树实现的，所以这里的K是需要可比较的，因此实现了Comparable
 * */
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;
    }

    // 向二分搜索树中添加新的元素(key, value)
    @Override
    public void add(K key, V value) {
        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所在的节点
    @SuppressWarnings("unused")
    private Node getNode(Node node, K key) {
        if (node == null) {
            return null;
        }

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

    @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;
    }

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

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

    // 从二分搜索树中删除键为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;
        }
    }

    // 返回以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;
    }

}

3、基于链表实现的Map

package com.zfy.setandmap;

public class LinkedListMap<K, V> implements Map<K, V> {
    
    /*
     * 因为前面的链表只能承载一个元素e，因此对于这里的映射类，我们需要重新重新实现Node了
     * */
    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;
    }
    
    //传来一个k的值，返回这个k所对应的节点的引用，后面的增删改查都将借助于这个方法
    private Node getNode(K key){
        Node cur = dummyHead.next;//cur对应dummyHead的next节点，就是第一个元素
        //循环遍历判断cur是否包含传入的key，如果包含则返回cur，否则继续遍历
        while (cur != null) {
            if (cur.equals(key)) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }
    
    @Override
    public void add(K key, V value) {
        Node node = getNode(key);//首先调用这个方法，然后判断返回后的当前节点中是否包含添加所传入的key键所对应的数据，如果没有则添加，有则覆盖
        if (node == null) {
            dummyHead.next = new Node(key, value, dummyHead.next);
            size ++;
        }else {
            node.value = value;
        }
    }

    //此方法发与之前的类似
    @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 != null) {
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size --;
            return delNode.value;
        }
        return null;
    }

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

    @Override
    public V get(K key) {
        Node node = getNode(key);//先调用getNode，返回所对应的节点，然后对其进行判断
        return node == null ? null :node.value;
    }

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

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

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

}

4、用二分搜索树实现的映射与用链表实现的映射的性能比较

import java.util.ArrayList;

public class Main {

    public static double testMap(Map<String, Integer> map, String filename) {

        long startTime = System.nanoTime();

        System.out.println(filename);
        ArrayList<String> words = new ArrayList<>();
        if (FileOperation.readFile(filename, words)) {
            System.out.println("Total words: " + words.size());
            for (String word : words) {
                if (map.contains(word)) {
                    map.set(word, map.get(word) + 1);
                } else {
                    map.add(word, 1);
                }
            }

            System.out.println("Total different words: " + map.getSize());
            System.out.println("Frequency of PRIDE: " + map.get("pride"));
            System.out.println("Frequency of PREJUDICE: " + map.get("prejudice"));
        }

        long endTime = System.nanoTime();

        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {

        String filename = "pride-and-prejudice.txt";

        LinkedListMap<String, Integer> linkedListMap = new LinkedListMap<>();
        double time1 = testMap(linkedListMap, filename);
        System.out.println("Linked List Map, time: " + time1 + " s");

        System.out.println();
        System.out.println();

        BSTMap<String, Integer> bstMap = new BSTMap<>();
        double time2 = testMap(bstMap, filename);
        System.out.println("BST Map, time: " + time2 + " s");

    }
}

          输出结果：

pride-and-prejudice.txt
Total words: 125901
Total different words: 6530
Frequency of PRIDE: 53
Frequency of PREJUDICE: 11
Linked List Map, time: 9.692566895 s


pride-and-prejudice.txt
Total words: 125901
Total different words: 6530
Frequency of PRIDE: 53
Frequency of PREJUDICE: 11
BST Map, time: 0.085364242 s

 

 

         通过比较结果，我们发现，用二分搜索树实现的映射的比用链表实现的映射更加高效。

 

4、映射的时间复杂度

 

  • 上图中"h"是二分搜索树的高度 
  • 当二分搜索树"满"的时候，性能是最佳的，时间复杂度为O(logn)；当二分搜索树退化为链表的时候，性能是最差的，时间复杂度为O(n)

 

3 集合与映射
11-29
国防工业大学高数(一)课件。。。。。与国防工业大学出的书配套课件。
集合论知识总结——映射
m0_62249876的博客
07-28 8530
定理3 设f:X→Y，g:Y→Z，若f和g都是可逆的，则gf也是可逆的且(gf)-1=f-1g-1，（f–1)-1=f。若|S|=n，则S上的置换称为n次置换。：设f:X→Y，A⊆X，由f和Ａ可以唯一的确定Ｙ 中的一个子集，记为f(A)，f(A)={f(x)|x。A，h(x)=g(f(x))，则称h为映射f与g的合成。1.限制与扩张：设f:Ｘ→Y，A⊆X，当把f的定义域限制在Ａ上时，就得到了一个j:A→Y，"x。(2)若存在一个映射h:Y→X,使得fh=IY，则称f是右可逆的，而h称为f的右逆映射。
集合映射详解
Shirley_John_Thomas的博客
09-11 5158
一、集合映射   1.1 集合小介      集合映射也是基本的映射，但在开发过程中不会经常用到，所以不需要深刻了解，只需要理解基本的使用方法即可，等在开发过程中遇到了这种问题时能够查询到解决方法就可以了。对应集合映射它其实是指将java中的集合映射到对应的表中，是一种集合对象的映射，在java中有四种类型的集合，分别是Set、Map、List还有普通的数组，它们之
9.集合与映射
EdSheeran的博客
08-02 959
文章目录*集合**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枚举集
集合和映射
DramaLifes的博客
07-25 395
集合 我觉得集合也是一个储存数据的容器，要注意集合再添加元素的时候不能添加重复的元素，对于集合来说我们首先需要创建一个接口，然后再用我们学过的数据结构作为基类实现接口 接口实现代码如下 public interface Set<E> { void add(E e); void remove(E e); boolean contains(E e); int getSize(); ...
集合与映射的实现
qq_22230709的博客
08-09 1572
                                                    集合与映射（Map和Set） 1.集合与映射是一种高层的数据结构 我们之前实现了二分搜索树，不能盛放相同元素，是一种非常好的实现“集合”的底层数据结构 由于集合可以使用不同的底层数据结构来实现，我们将我们的set定义为一个接口 因此我们这里使用链表和二分搜索树实现set，并且比较...
集合、映射与函数
Nuyoah2001的博客
04-02 2841
集合、映射与函数集合集合的定义集合的特性集合之间的包含关系数集与点集 集合 集合的定义 具有一个特定属性的，确定的，有区别的事物（不论是抽象的还是具体的）的全体称为集合，集合中的事物称为元素。 若a是集合A中的元素，记为a ∈\in∈ A。 若a不是集合A中的元素，记为a ∉\notin∈/​ A。 集合的特性 确定性 互异性 无序性 集合之间的包含关系 两个集合A、B，若 ∀\forall∀ x ∈\in∈ A，都有x ∈\in∈ B，则称A是B的子集，记为A ⊂\su
14、Kotlin 集合框架：集合、列表与映射的深入解析
sugar的博客
08-02 127
本文深入解析了 Kotlin 集合框架中的三种核心数据结构：集合（Set）、列表（List）和映射（Map）。详细介绍了它们的创建方式、常用操作函数以及使用场景，并通过示例代码帮助开发者更好地理解和应用这些数据结构。无论您是初学者还是有经验的开发者，都能从中获得实用的知识，提升 Kotlin 编程能力。
掌握JavaScript中的集合与映射操作
weixin_42300144的博客
05-16 342
本文将深入探讨JavaScript中的集合(Set)和映射(Map)的操作方法。通过具体的代码示例和应用场景，展示了如何在Set中添加元素、使用迭代器访问Set元素，以及如何在Map中添加、获取和删除元素。本文旨在帮助读者更好地理解和运用这些数据结构。
初等数学O 集合论基础 第二节 映射与集合的势
一个不愿透露姓名的博客
11-29 927
初等数学O 集合论基础 第二节 映射与集合的势 这一节的目标是基于映射建立比较集合“大小”的工具——集合的势(cardinality)，也被称为集合的基数，这个工具是自然数的基数理论的基础。 定义0.6 映射 X,YX,YX,Y是两个非空集合，称f:X→Yf:X \to Yf:X→Y是一个映射，如果 ∀x∈X,∃!y∈Y,f(x)=y\forall x \in X, \exists !y \in Y,f(x)=y∀x∈X,∃!y∈Y,f(x)=y 称XXX为原像空间，YYY为像空间，f(X)f(X)f(X
Java集合与映射中的对象比较
weixin_35509395的博客
03-30 321
本文通过Java代码示例深入探讨了如何在集合与映射中比较对象。具体包括对象引用和值的相等性测试、如何在数组、集合或映射中搜索对象，以及如何正确地覆盖equals()和hashCode()方法以保证对象的正确比较。文章还详细解释了等价关系的性质，并提供了一个实现equals()方法的checklist。
算法与数据结构之集合和映射
谁D了我的BUG
05-17 263
集合(Set) 集合:承载元素的容器，每个元素只能存在一次 应用:客户统计，词汇量统计 该集合所包含的操作： public interface Set<E> { void add(E e); void remove(E e); boolean contains(E e); int getSize(); boolean isEmpty(); } 基于二分搜索树的集合实现 参考...
Scala编程实践：集合与映射操作
最新发布
hadoop5ranger的博客
09-13 898
本文介绍了多个Scala编程实践问题，包括集合与映射的操作、不可变与可变数据结构的使用、异常处理、模式匹配以及类与对象的设计。涵盖内容有flatten方法的使用、Map键值对的转换、Set集合的增删操作、Vector的更新机制、颜色混合逻辑的实现、Option类型的应用、前置后置条件检查、日志配置修改以及类型类的扩展等。
Hibernate集合映射与关联关系映射
棉花糖老丫
05-05 1045
本文主要讲解Hibernate的主键策略、Hibernate数据类型与Java数据类型关系、集合映射、关联关系映射。
15、深入探索对象关系映射与集合映射
carrot的博客
07-09 51
本文深入探讨了对象关系映射（ORM）与集合映射的核心概念和实际应用。内容涵盖单向关系映射、懒加载机制、嵌入式对象的使用、集合映射的类型及其存储方式，以及性能优化策略。通过具体代码示例，详细解析了实体集合、嵌入式对象集合和基本类型集合的映射方法，并讨论了其在员工信息管理系统和电商系统中的实际应用场景。旨在帮助开发者更好地理解和运用ORM技术，提高系统的性能与可维护性。
17、集合映射与实体关联详解
wdx01234567的博客
07-08 45
本文详细探讨了在使用 Hibernate 和 JPA 进行数据持久化时，如何合理选择和使用集合映射类型，如 Set、List、Map 及其排序和有序变体。内容涵盖了集合映射的优势与挑战、接口选择、具体映射方式、事务性文件系统集成以及操作流程总结，旨在帮助开发者更好地理解和应用集合映射与实体关联的相关技术。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值