数据结构-集合和映射篇

最新推荐文章于 2024-08-13 09:56:30 发布
最新推荐文章于 2024-08-13 09:56:30 发布
阅读量611 收藏
点赞数
分类专栏： 数据结构 java 文章标签： 数据结构 java 集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33253337/article/details/114092499
版权

数据结构-集合和映射篇

文章目录

一. 集合（Set）

Set

Void add(E) 不能添加重复元素 应用：客户统计、词汇量统计

Void remove(E)

Boolean contains(E)

Int getSize()

Boolean isEmpty()

1. 定义集合
/**
 * 集合接口
 * @param <E>
 */
public interface Set<E> {
    void add(E e);
    void remove(E e);
    boolean contains(E e);
    int getSize();
    boolean isEmpty();
}
2. 基于二分搜索树的集合定义
public class BSTSet<E extends Comparable<E>> implements Set<E>{

    private BST<E> bst;

    public BSTSet(){
        bst = new BST<>();
    }
    @Override
    public void add(E e) {
        bst.add(e);
    }

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

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

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

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

方法对应上一章二分搜索树的结构定义

测试类

public static void main(String[] args) {
    System.out.println("Pride and Prejudice");

    ArrayList<String> words1 = new ArrayList<>();
    if (FileOperation.readFile("pride-and-prejudice.txt", words1)) {
        System.out.println("Total words: " + words1.size());

        BSTSet<String> set1 = new BSTSet<>();
        for (String word : words1)
            set1.add(word);
        System.out.println("Total different words: " + set1.getSize());
    }
}

BST和LinkedList都属于动态数据结构

BST:

Class Node{
	E e;
	Node left;
	Node right;
}

LinkedList:

 Class Node{
 	E e;
 	Node next;
 }
3. 基于链表的集合定义
import java.util.ArrayList;

public class LinkedListSet<E> implements Set<E> {
    private LinkedList<E> list;

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

    @Override
    public void add(E e) {
        if(!list.contains((e))){
            list.addFirst(e);
        }
    }

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

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

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

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

测试类

public static void main(String[] args) {
        System.out.println("Pride and Prejudice");

        ArrayList<String> words1 = new ArrayList<>();
        FileOperation.readFile("pride-and-prejudice.txt", words1);
        System.out.println("Total words:" + words1.size());

        LinkedListSet<String> set1 = new LinkedListSet<>();
        for(String word:words1){
            set1.add(word);
        }
        System.out.println("Total different words:" + set1.getSize());
}
4. 集合类复杂度分析

对比二分搜索树和链表，代码如下：

import java.util.ArrayList;

public class SetMain {
    private 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("BST Set:" + time1 + "s");

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

对比结果：

pride-and-prejudice.txt Total words:125901 Total different words:6530

BST Set:0.4018152s

pride-and-prejudice.txt Total words:125901 Total different words:6530

LinkedListSet:4.8493949s

5. 集合的时间复杂度分析
方法LinkedListSetBSTSet平均最差
增addO(n)O(n)O(logn)O(n)
查 containsO(n)O(n)O(logn)O(n)
删 removeO(n)O(n)O(logn)O(n)

计算h层一共有多少个节点

logn 和 n 的差距

lognn
n=16416相差4倍
n=1024101024相差100倍
n=100万20100万相差5万倍

有序集合和无序集合

  • 有序集合中的元素具有顺序性 →基于搜索树的实现

  • 无序集合中的元素没有顺序性 →基于哈希表的实现

多重集合

  • 集合中的元素可以重复
二. 映射

在这里插入图片描述

  • 存储（键，值）数据对的数据结构（Key,Value）

  • 根据键（Key），寻找值（Value）

    在这里插入图片描述

1. 定义映射接口
public interface Map<K,V> {
    void add(K key);
    V remove(K key);
    boolean contains(K key);
    V get(K key);
    void set(K key,V value);
    int getSize();
    boolean isEmpty();
}
2. 基于链表的映射节点构造
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){
        this(key,null,null);
    }
    public Node(){
        this(null,null,null);
    }

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

基于链表的映射实现

public class LinkedListMap<K, V> implements Map<K, V> {
   //加入上面的节点类
    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;
    }
    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) {
            dummyHead.next = new Node(key, value, dummyHead.next);
            size++;
        } else {
            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;
    }
}

测试类

public static void main(String[] args) {
    System.out.println("Pride and Prejudice");

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

        LinkedListMap<String,Integer> map = new LinkedListMap<>();
        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.getNode("pride"));
        System.out.println("Frequency of PREJUDICE: " + map.get("prejudice"));
    }
}

测试结果：

Total words:125901

Total different words :6530

Frequency of PRIDE:pride:53

Frequency of PREJUDICE: 11

3. 基于二分搜索树的映射节点构造
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;
    }
}

基于二分搜索树的映射实现

public class BSTMap<K extends Comparable<K>, V> implements Map<K, V> {
//创建上面的节点
    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) {
        root = add(root, key, value);
    }
//向以node 为根的二分搜索树中插入元素K key,V 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 {
            node.value = value;
        }
        return node;
    }

    //返回以Node为根节点的二分搜索树中，key所在的节点
    private Node getNode(Node node, K key) {
        if (node == null) {
            return null;
        }
        if (key.compareTo(node.key) == 0) {
            return node;
        } else if (key.compareTo(node.key) < 0) {
            return getNode(node.left, key);
        } else {
            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,value)的节点
    @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 {
            //待删除节点左子树为空的情况
            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;
        }
    }
}

测试类

public static void main(String[] args) {
    System.out.println("Pride and Prejudice");

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

        LinkedListMap<String,Integer> map = new LinkedListMap<>();
        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"));
    }
}

测试结果:

Pride and Prejudice

Total words:125901

Total different words :6530

Frequency of PRIDE:53

Frequency of PREJUDICE: 11

4. 映射的时间复杂度分析
方法LinkedListMapBSTMap平均最差
增 addO(n)O(h)O(logn)O(n)
删 removeO(n)O(h)O(logn)O(n)
改 setO(n)O(h)O(logn)O(n)
查 getO(n)O(h)O(logn)O(n)
查 containsO(n)O(h)O(logn)O(n)

对比代码如下：

public class MapMain {
    private static double testMap(Map<String,Integer> map,String filename){
        long startTime = System.nanoTime();

        System.out.println("Pride and prejudice:");

        ArrayList<String> words = new ArrayList<>();
        if(FileOperation.readFile("Pride-and-prejudice.txt",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";
        BSTMap<String,Integer> bstMap = new BSTMap<>();
        double time1 = testMap(bstMap,filename);
        System.out.println("BST Map:" + time1 + "s");

        System.out.println();
        LinkedListMap<String,Integer> linkedListMap = new LinkedListMap<>();
        double time2 = testMap(linkedListMap,filename);
        System.out.println("LinkedListMap:" + time2 + "s");
    }
}

对比结果如下：

Pride and prejudice:

Total words:125901

Total different words :6530

Frequency of PRIDE:53

Frequency of PREJUDICE: 11

BST Map:0.1658282s

Pride and prejudice:

Total words:125901

Total different words :6530

Frequency of PRIDE:53

Frequency of PREJUDICE: 11

LinkedListMap:16.6475049s

有序映射和无序映射

  • 有序映射中的键具有顺序性 → 基于搜索树的实现

  • 无序映射中的键没有顺序性 → 基于哈希表的实现

多重映射

  • 多重映射中的键是可以重复的
5. 集合和映射的关系

ZJ慧
关注
专栏目录
集合与映射
Marmara
04-11 688
一、集合 1、 集合的应用 集合可以用来去重 集合可以用于进行客户的统计 集合可以用于文本词汇量的统计 2、集合的实现 （1）对于集合的一些定义，我们一般也都了解，例如集合一般都不会存放重复的元素，因此这就让它有了去重的功用了。 public interface Set<E> { void add(E e);//不能添加重复元素 boolean c...
魔术里的集合、映射和关系（三）——关系和映射的关系
magic2728的博客
02-14 3055
上回说到，集合的用法。从表示，关系，运算以及性质四个角度展开，并最后尝试构建了一个集合观下的世界。不妨注意这四个角度，很多数学概念都是从这些角度展开的：先有表示，然后是性质，以及内部关系...
【LabVIEW学习篇 - 14】：信号量、集合点、事件发生
最新发布
Oh_Python的博客
08-13 933
信号量技术是用来限制同时访问共享资源的数量。当访问量达到信号量设定的数量之后，其它任务只能等待，直到有任务释放访问权限。比如打印机打印任务、银行办理业务时的叫号排队等等。：使用信号量，实现两个波形图表轮流显示数据。例如：当CH1获取该信号量时，CH2处于等待状态，当CH1释放信号量时，CH2获取信号量，CH1处于等待状态。第2个while循环的设置与第一个while循环相同，不同的是赋值的对象为CH2。
数据结构--集合与映射（九）
九曜
03-12 543
以下是学习恋上数据结构与算法的学习笔记，本篇主要内容是集合与映射 ◼集合（Set） ●集合的特点 ●不存放重复的元素 ●常用于去重 ✓存放新增IP，统计新增IP 量 ✓存放词汇，统计词汇量 思考：集合的内部实现能否直接利用以前学过的数据结构？ 动态数组、链表、二叉搜索树（AVL树、红黑树）。 集合的接口设计 public interface Set<E> { int size();...
算法与数据结构之集合和映射
谁D了我的BUG
05-17 197
集合(Set) 集合:承载元素的容器，每个元素只能存在一次 应用:客户统计，词汇量统计 该集合所包含的操作： public interface Set<E> { void add(E e); void remove(E e); boolean contains(E e); int getSize(); boolean isEmpty(); } 基于二分搜索树的集合实现 参考...
数据结构与算法分析（十三）--- 集合与映射 + Set/Map容器（C++11）
流云
01-16 2549
一、集合与映射 人们把一堆东西放到一起，就称之为集合了。一般来讲，集合是具有某种特性的事物的整体，或是一些确认对象的汇集，构成集合的事物或对象称作元素或是成员。集合的元素可以是任何事物，集合具有无序性、互异性、确定性等特性。 在数学上，我们可以把映射看作是集合与集合之间的一种对应关系，比如函数实际上就是数的集合到数的集合之间的映射关系。计算机更擅长处理数字编号，我们的大脑更擅长处理概念词汇，因此我们经常需要通过某个关键词key来查询一组数据的信息value，于是就把这种映射关系抽象为一个数据结构：键值对。
DataStructures:在纯 Matlab 中实现的设置和映射数据结构-matlab开发
06-01
本项目专注于在不依赖外部 C 语言扩展的情况下，在纯 MATLAB 环境中实现数据结构，特别是排序集（使用红黑树）和关联映射（通常称为哈希表或字典）。这里我们将详细探讨这两个数据结构及其实现。 1. 排序集（红黑树...
cpp-C哈希映射集合保留插入的顺序
08-16
在C++编程中，哈希映射（HashMap）和集合（Set）是两种常用的数据结构。它们提供了快速的键值查找和元素存储功能。然而，标准库中的`std::unordered_map`和`std::unordered_set`并不保留元素的插入顺序，这可能会在...
JAVA培训-HIBERNATE的集合映射.doc
06-28
可以处理键值对形式的数据结构。 - **Bag**: 实际上就是`List`的一个别名，同样使用`<list>`标签进行映射，但默认是无序的。 #### 总结 通过上述内容，我们可以看到Hibernate框架提供了一套完善的集合映射机制，...
集合和映射表（一）
weixin_52273794的博客
03-13 789
介绍Java合集框架中的集合和映射表。
数据结构基础_集合与映射
coding
11-16 1039
一. 集合（Set） 类似于栈和队列，是一种高层数据结构，往往通过实现接口来完成，底层可以选用不同的数据结构 集合是一种不包含重复数据的容器，可以用于数据的去重操作 实现集合的关键是在添加元素时，不能包含重复元素（底层可以通过不包含重复元素的二分搜索树实现，也可以使用链表实现） 集合的典型应用：客户统计，词汇量统计   以二分搜索树和以链表为底层实现的集合的性能比较： 在链表的头部...
集合和映射
DramaLifes的博客
07-25 303
集合 我觉得集合也是一个储存数据的容器，要注意集合再添加元素的时候不能添加重复的元素，对于集合来说我们首先需要创建一个接口，然后再用我们学过的数据结构作为基类实现接口 接口实现代码如下 public interface Set<E> { void add(E e); void remove(E e); boolean contains(E e); int getSize(); ...
集合与映射的实现
qq_22230709的博客
08-09 1456
                                                    集合与映射（Map和Set） 1.集合与映射是一种高层的数据结构 我们之前实现了二分搜索树，不能盛放相同元素，是一种非常好的实现“集合”的底层数据结构 由于集合可以使用不同的底层数据结构来实现，我们将我们的set定义为一个接口 因此我们这里使用链表和二分搜索树实现set，并且比较...
映射文件中的集合属性和组成关系映射
02-25 1342
一.映射文件中的集合属性有：List、Set、Array、Bag、Map、idbag      1. Set：无序、不可重复         Set集合元素：key、element             元素来映射持久化类的set类型的属性                    name：设定待映射持久化类的属性名                    cascade：设定级联
9.集合与映射
EdSheeran的博客
08-02 788
文章目录*集合**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枚举集
【玩转数据结构Part3】集合和映射
aaon22357的博客
07-08 293
集合和映射是一种高级的数据结构，它的底层是由BST实现的。 栈和队列的底层，既可以是动态数组，也可以是链表，是BST 文章目录集合set（支持增删查）添加元素add查找元素contains删除元素remove总结& 分析映射map（也称字典，支持增删改查）添加元素add查找元素contains删除元素remove修改元素总结& 分析集合和映射的关系 集合set（支持增删查） 去重操...
探索数据结构：集合、映射与列表的实战应用
在本篇文章中，我们深入探讨了算法与数据结构的基础概念，特别是集合、映射和列表，以及它们在编程中的重要性。文章以Python为例，通过处理一个名为"txt.txt"的文本文件，展示了如何利用这些数据结构来理解数据类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值