【玩转数据结构 从入门到进阶6学习笔记】集合与映射

最新推荐文章于 2020-12-08 21:42:45 发布
置顶 最新推荐文章于 2020-12-08 21:42:45 发布
阅读量172 收藏
点赞数
分类专栏： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43372187/article/details/106222650
版权

集合

只要实现以下方法就可实现一个简单的集合

public interface Set<E> {
    void add(E e);//不能添加元素
    void remove(E e);
    boolean contains(E e);
    int getSize();
    boolean isEmpty();
}

可以使用二分搜索树和链表实现集合，首先来看一下二分搜索树的实现，我们这里导入之前创建的BST类，注意这里的泛型要实现Comparable接口，

import java.util.ArrayList;
public class BSTSet<E extends Comparable<E>> implements Set<E> {

    private  BST1<E> bst1;

    public BSTSet(){
        bst1=new BST1<>();
    }

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

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

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

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

    @Override
    public boolean isEmpty(){
        return bst1.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());
        }

        System.out.println();

        System.out.println("A Tale of Two Cities");

        ArrayList<String> words2 = new ArrayList<>();
        if (FileOperation.readFile("a-tale-of-two-cities.txt", words2)) {
            System.out.println("Total words: " + words2.size());

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

打开文件也有一个类：

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Locale;
import java.util.Scanner;

// 文件相关操作
public class FileOperation {

    // 读取文件名称为filename中的内容，并将其中包含的所有词语放进words中
    public static boolean readFile(String filename, ArrayList<String> words){

        if (filename == null || words == null){
            System.out.println("filename is null or words is null");
            return false;
        }

        // 文件读取
        Scanner scanner;

        try {
            File file = new File(filename);
            if(file.exists()){
                FileInputStream fis = new FileInputStream(file);
                scanner = new Scanner(new BufferedInputStream(fis), "UTF-8");
                scanner.useLocale(Locale.ENGLISH);
            }
            else
                return false;
        }
        catch(IOException ioe){
            System.out.println("Cannot open " + filename);
            return false;
        }

        // 简单分词
        // 这个分词方式相对简陋, 没有考虑很多文本处理中的特殊问题
        // 在这里只做demo展示用
        if (scanner.hasNextLine()) {

            String contents = scanner.useDelimiter("\\A").next();

            int start = firstCharacterIndex(contents, 0);
            for (int i = start + 1; i <= contents.length(); )
                if (i == contents.length() || !Character.isLetter(contents.charAt(i))) {
                    String word = contents.substring(start, i).toLowerCase();
                    words.add(word);
                    start = firstCharacterIndex(contents, i);
                    i = start + 1;
                } else
                    i++;
        }

        return true;
    }

    // 寻找字符串s中，从start的位置开始的第一个字母字符的位置
    private static int firstCharacterIndex(String s, int start){

        for( int i = start ; i < s.length() ; i ++ )
            if( Character.isLetter(s.charAt(i)) )
                return i;
        return s.length();
    }
}

结果：

Pride and Prejudice
Total words: 125901
Total different words: 6530

A Tale of Two Cities
Total words: 141489
Total different words: 9944

接着用链表实现，实现原理也跟树的相似，导入之前的LinkedList这个类，调用类的方法，

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

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

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

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

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

    public void remove(E e){
        list.removeElement(e);
    }
    //集合中不能包含相同元素，所以要做个判断，判断集合无该元素才可添加
    public void add(E e){
         if (!list.contains(e)){
             list.addFirst(e);
         }
    }
}

映射

存储（键，值）数据对的数据结构（Key,Value）
根据键，寻找值
映射非常容易使用链表和二分搜索树实现

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 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();
        }
    }

先是基于BST的实现，这里的Key要实现Comparable接口，

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

接着向二分搜索树添加元素，

// 向二分搜索树中添加新的元素(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所在的节点
    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;
        }
    }

接下来基于链表的实现原理也是相似

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;
    }
爱技术的小小林
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
慕课网liuyubobobo老师课程学习笔记---part2 :栈和队列
LKJgdut的博客
03-31 570
1、栈   栈也是一种线性结构，相比数组，栈对应的操作是数组的子集。栈只能从一端添加元素，也只能从一端取出元素，这一端称为栈顶。   栈是一种后进先出的数据结构——Last In First Out（LIFO），在计算机的世界里，栈拥有着不可思议的作用。 栈的应用 1）无处不在的Undo操作（撤销）； 2）程序调用的系统栈。（子过程子逻辑的调用） 栈的实现   这部分参考StackT...
数学分析_笔记_第1章：集合与映射
dc12499574的博客
06-22 144
笔记
高等数学学习笔记——第三讲——集合与映射（4. 映射与集合的比较）
预见未来to50的专栏
10-16 497
1. 映射（像、原像、定义域、值域） 2. 单射、漫射、双射（一一映射） 3. 集合等势的概念
hibernate集合映射学习笔记
轻描淡写
11-03 251
12520171102 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
玩转数据结构从入门到进阶一
后台开发
12-08 325
下载地址：https://pan.baidu.com/s/1bmr_ncQz5Fnko7oo9OkrTw 提取密码：3bm9
013 《数据分析从入门到进阶》读书笔记
01-07
看过的道、术有一些积累了，但真正存入脑海...《数据分析从入门到进阶》作者：陈红波，刘顺祥等 摘记 一、数据分析之道、术及工具（excel,sql,tableau） 二、python数据分析回归模型常用技术 作者：积跬步，慕至千里
R语言学习笔记，R语言数据分析从入门到进阶-代码合集
01-13
R语言学习笔记，R语言数据分析从入门到进阶-代码合集R语言学习笔记，R语言数据分析从入门到进阶-代码合集R语言学习笔记，R语言数据分析从入门到进阶-代码合集R语言学习笔记，R语言数据分析从入门到进阶-代码合集R...
R语言学习笔记，R语言数据分析从入门到进阶-代码合集。.zip
01-12
本资料集合是一份全面的R语言学习笔记，旨在帮助初学者从入门到进阶，掌握R语言在数据分析中的应用。 1. **R语言基础**：R语言的学习始于了解其语法和基本结构。这包括变量的创建、赋值和数据类型（如数值、字符、...
javase全套学习笔记，从入门到进阶详细笔记
12-19
本学习笔记旨在为初学者提供从入门到进阶的全面指导，覆盖了Java技术的基础和核心概念。 1. Java技术基础 - **编程语言**：编程语言是人与计算机交流的工具，Java作为高级语言，具有简洁、面向对象、可移植性好等...
ElasticSerach7入门与进阶实战学习笔记
最新发布
07-12
ElasticSerach7入门与进阶实战学习笔记
玩转数据结构从入门到进阶笔记（二 链表）
sinat_36748650的博客
04-16 477
链表Linked List： 上一篇中的动态数组，栈和两种队列底层依然依托于静态数组，其中动态是对于该数据结构的使用者来说的，依靠 resize方法解决动态扩容和缩容的问题。而链表是真正的动态数据结构，同时也是最简单的数据结构，是其他复杂数 据结构的基础。 它的数据储存在节点中，称之为Node，Node中储存了一个保存的数据和指向下一个节点的Node类型的引用next。下一 个节点没有数据则指向n...
【玩转数据结构 从入门到进阶9学习笔记】字典树Trie
weixin_43372187的博客
05-21 152
什么是Trie 上图便是一棵字典树，它是一棵多叉树，它通常只用来处理字符串，当数据为单词的时候，把单词以字母为单位一个一个拆开，从根节点开始，一直到叶子节点去遍历，每遍历到一个叶子节点形成一个单词。所以它的时间复杂度为O（w），w为字符串的长度。 字典树还有一个问题，就是当一个单词的前缀也为一个单词，如pan为平底锅，是panda的前缀，该如何表示，我们就需要一个标识符，去标识该节点是一个单词的结尾，我们还用到了映射，一个字符对应一个节点，这两部分构成了字典树的基本节点类 字典树基础 public cla
《玩转数据结构 从入门到进阶》二叉堆
CodingSoldier的博客
08-08 250
本文来源于liuyubobobo的“玩转数据结构 从入门到进阶”视频教程 先介绍几个概念 1、满二叉树如下图： 2、完全二叉树 3、二叉堆 使用数组实现一个最大二叉堆。 上图中的树只是数组存储元素的形象画法，实际存储数据的还是数组，但数组元素之间具备树那样的关系。 假设当前节点下标为i（i也是数组的下标），最大堆的下标存在这样的关系： 父亲节点下标与当前节点下...
陈纪修老师《数学分析》 第01章：集合与映射 笔记
石贤芝
04-30 2491
本章介绍了集合和映射相关的基本概念，这是高中里已经学过的东西。集合与映射是现代数据的基本ABC术语。知识点如下：
DS12-映射的两种实现方式(链表实现和二分搜索树实现)
qq_42296882的博客
02-24 152
映射Map主要是指在数据存储中一个键key唯一对应一个值value,是一种应用比较广泛的数据结构,实现映射可以采用多种方法,使用链表实现映射的时间复杂度为O(n),使用二分搜索树实现的映射的时间复杂度稍微好一些,为O(logN). 实现映射与实现集合的思路大体相同,只是映射需要在构建节点时在其中加一个V类型的value,并在后续的代码实现中维护这个value,映射中的key也可以理解为一种唯一标识...
高等数学学习笔记——第三讲——集合与映射（1. 集合的概念与运算）
预见未来to50的专栏
10-15 1717
1. 集合的定义 2. 数集的表示 3. 集合运算 4. 集合的运算性质 5. 直积
【JAVA高薪之路 面试题精选】Map类面试题
weixin_43372187的博客
05-25 890
知识结构及题目分析 ​ 一般而言，Map 的面试题可分为四类： 1、HashMap 的数据结构，面试官考察的是对 Map 内部的存储结构了解； 2、HashMap 的增删查改操作，面试官考察的是对 map 内部操作流程的熟悉程度，既要知其然，还要知其所以然； 3、HashMap 的的应用，面试官考察的是灵活运用 HashMap 的能力； 4、其他 Map 类面试题，面试官考察的是系统掌握 Map 类的能力。 典型例题及思路分析 问题 1："那你知道 HashMap 内部的数据结构吗？" 参考答案： ​ 各个
JAVA基础之If-else循环，do-while循环
weixin_43372187的博客
04-08 650
JAVA循环之if-else和do-while 对数字求特征值是常用的编码算法，奇偶特征是一种简单的特征值。对于一个整数，从个位开始对每一位数字编号，个位是1号，十位是2号，以此类推。这个整数在第n位上的数字记作x，如果x和n的奇偶性相同，则记下一个1，否则记下一个0。按照整数的顺序把对应位的表示奇偶性的0和1都记录下来，就形成了一个二进制数字。比如，对于342315，这个二进制数字就是00110...
Go语言学习笔记：从入门到进阶指南
4. **数据结构**：涉及数组（Array）、切片（Slice）、映射（Map）以及结构体（Struct）的使用。 5. **方法**：介绍了方法定义、匿名字段、方法集和表达式的应用。 6. **接口**：讲解接口的定义、执行机制、转换和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱技术的小小林

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值