数据结构与算法_05【集合与映射】

最新推荐文章于 2023-12-15 08:37:08 发布
最新推荐文章于 2023-12-15 08:37:08 发布
阅读量159 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44561640/article/details/102723158
版权

1.集合（Set）

集合：存储不重复元素的容器

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

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

顺序性，是指按照元素的大小进行排序，并非指插入的顺序

有序性，是指元素的进场顺序和出场顺序一致

应用场合： 客户统计 词汇量统计
Set集合接口定义

public interface Set<E> {
	public void add(E e); 	 //向集合中添加元素e（不能添加重复元 素）
	public void remove(E e);	//删除集合中指定元素e 
	public boolean contains(E e);	 //判断是否包含指定元素e 
	public int getSize();	//获取集合中元素的个数 
	public boolean isEmpty();	//判断集合是否为空 
}

BSTSet基于二分搜索树实现的集合类定义

public class BSTSet<E extends Comparable<E>> implements Set<E> {
	private BinarySearchTree<E> bst;
	public BSTSet() {
		bst=new BinarySearchTree<>();
	}
	@Override
	public void add(E e) {//O(logn)->O(n)
		bst.add(e);
	}

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

	@Override
	public boolean contains(E e) {//O(logn)
		return bst.contains(e);
	}
	//O(nlogn) 
	@Override
	public int getSize() {
		return bst.size();
	}

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

LinkedListSet基于链表实现的集合类定义

//基于链表实现的集合
public class LinkedSet<E> implements Set<E>{
	private LinkedList<E> list;
	public LinkedSet() {
		list=new LinkedList<>();
	}
	@Override
	public void add(E e) {	//O(n)
		if(!list.contains(e)){
			list.addLast(e);//O(1)
		}
	}

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

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

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

读取小说中的单词，对比两种不同的实现方式（时间复杂度分析）
 

public class Main2 {
	public static void main(String[] args) {
		ArrayList<String> words=new ArrayList<>();
		FileOperation.readFile("pride-and-prejudice.txt", words);
		long start=System.currentTimeMillis();
//		LinkedMap<String, Integer> map=new LinkedMap<>();
		BSTMap<String, Integer> map=new BSTMap<>();
		for(int i=0;i<words.size();i++){
			String word=words.get(i);
			if(map.contains(word)){
				map.set(word, map.get(word)+1);
			}else{
				map.add(word, 1);
			}
		}
		long end=System.currentTimeMillis();
		double second=(end-start)/1000.0;
		System.out.println("用时："+second);
		System.out.println("map的长度："+map.getSize());
		System.out.println("she:"+map.get("she"));
		System.out.println(map.keys());
	}
}

Java中对于集合相关的常见内置类有哪些 

 

2.映射（Map）  

 

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

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

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

Map接口定义 

public interface Map<K,V>{
	public void add(K key,V value);
	public V remove(K key);
	public boolean contains(K key);
	public V get(K key);
	public void set(K key,V value);
	public int getSize();
	public boolean isEmpty();
	public Set keys();		//返回映射中键的集合
	public List values();	//返回映射中值的线性表
}

LinkedListMap基于链表实现的映射类定义

1.定义类 

public class LinkedMap<K,V> implements Map<K,V>

2.定义内部类结点 

//基于动态链表实现的映射
public class LinkedMap<K,V> implements Map<K,V>{
	private class Node{
		public K key;
		public V value;
		public Node next;
		public Node(K key,V value){
			this.key=key;
			this.value=value;
			next=null;
		}
		public Node(){
			this(null,null);
		}
		@Override
		public String toString() {
			return key.toString()+":"+value.toString();
		}
	}

3.定义成员变量
 

private Node head; 

private int size;

4.定义构造函数 

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

5.实现功能 

private Node getNode(Node node, K key) {
		if(node==null){
			return null;
		}
		if(node.key.equals(key)){
			return node;
		}else{
			return getNode(node.next,key);
		}
	}
	
	@Override
	public void add(K key, V value) {
		Node n=getNode(key);
		if(n==null){
			n=new Node(key,value);
			n.next=head.next;
			head.next=n;
			size++;
		}else{
			n.value=value;
		}
	}

	@Override
	public V remove(K key) {
		Node pre=head;
		while(pre.next!=null){
			if(pre.next.key.equals(key)){
				break;
			}
			pre=pre.next;
		}
		if(pre.next!=null){
			Node n=pre.next;
			pre.next=n.next;
			n.next=null;
			size--;
			return n.value;
		}
		return null;
	}

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

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

	@Override
	public void set(K key, V value) {
		Node n=getNode(key);
		if(n==null){
			throw new IllegalArgumentException("元素不存在！");
		}
		n.value=value;
	}

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

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

	@Override
	public Set keys() {
		Set<K> set=new LinkedSet<K>();
		Node cur=head.next;
		while(cur!=null){
			set.add(cur.key);
		}
		return set;
	}

	@Override
	public List values() {
		List<V> list=new LinkedList<V>();
		Node cur=head.next;
		while(cur!=null){
			list.addLast(cur.value);
		}
		return list;
	}

BSTMap基于二分搜索树实现的映射类定义

1.定义类

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

2.定义内部类结点 

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;
		}
		public Node(){
			this(null,null);
		}
		@Override
		public String toString() {
			return key.toString()+":"+value.toString();
		}
	}

3.定义成员变量 

    private Node root;	
	private int size;

4.定义构造函数

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

5.实现功能

@Override
	public void add(K key, V value) {
		root=add(root,key,value);
	}
	// 以node为根节点，将键值对k-v添加在树中 并返回新树的根
	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;
	}

	@Override
	public V remove(K key) {
		Node n=getNode(root,key);
		if(n==null){
			return null;
		}
		root=remove(root,key);
		return n.value;
	}
	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=minmum(node.right);
			successor.right=removeMin(node.right);
			successor.left=node.left;
			node.left=node.right=null;
			return successor;
		}
	}
	private Node minmum(Node node){
		if(node.left==null){
			return node;
		}else{
			return minmum(node.left);
		}
	}
	private Node removeMin(Node node){
		if(node.left==null){
			Node rightNode=node.right;
			size--;
			node.right=null;
			return rightNode;
		}
		node.left=removeMin(node.left);
		return node;
	}
	@Override
	public boolean contains(K key) {
		Node n=getNode(root,key);
		return n==null?false:true;
	}

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

	@Override
	public void set(K key, V value) {
		Node n=getNode(root,key);
		if(n==null){
			throw new IllegalArgumentException("元素不存在！");
		}
		n.value=value;
	}

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

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

	@Override
	public Set keys() {
		Set<K> set=new BSTSet<>();
		inOrder(root,set);
		return set;
	}
	private void inOrder(Node node, Set<K> set) {
		if(node==null){
			return;
		}
		inOrder(node.left, set);
		set.add(node.key);
		inOrder(node.right, set);
	}

	@Override
	public List values() {
		return null;
	}
	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;
		}
	}

林钟二五
关注
专栏目录
数据结构与算法——21. 抽象数据类型：映射（Map）
花城的博客
12-01 1409
文章目录一、抽象数据类型：映射（Map）二、实现ADT Mappython代码实现三、散列算法分析 一、抽象数据类型：映射（Map） 字典（Dict）是Python最有用的数据类型之一，可以保存key-vaule键值对，key可用于查询关联的数据值value。这种键值关联的方法称为“映射（Map）”。 ADT（抽象数据类型） Map的结构是键-值关联的无序集合，关键码具有唯一性，通过关键码可以唯一确定一个数据值。 二、实现ADT Map 使用字典的优势在于，给定关键码key，能够很快得到关联的数据值valu
python数据结构与算法 pdf_数据结构与算法：Python语言描述.pdf
weixin_39570777的博客
11-23 3665
本书基于Python语言介绍了数据结构与算法的基本知识，主要内容包括抽象数据类型和Python面向对象程序设计、线性表、字符串、栈和队列、二叉树和树、集合、排序以及算法的基本知识。本书延续问题求解的思路，从解决问题的目标来组织教学内容，注重理论与实践的并用。更多关于数据结构与算法的资源请访问：更多相关资源：出版者的话专家指导委员会译者序前言第1章引论第2章算法分析第3章表、栈和队列第4章树第5章散...
算法与数据结构之集合和映射
谁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(); } 基于二分搜索树的集合实现 参考...
7-玩转数据结构-集合与映射
weixin_33890526的博客
08-14 190
上一章我们详细的介绍了二分搜索树的底层实现。这章我们介绍两个高层的数据结构，集合和映射。这种高层的数据结构，更像是我们定义好了使用接口规则，但是具体的底层实现可以是多种多样的。 集合 承载元素的容器，元素的去重操作。回忆我们上一小节实现的二分搜索树是不能盛放重复元素的，非常好的实现“集合”的底层数据结构。 S...
数据结构与算法-集合与映射
最新发布
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
12-15 296
数学中的函数就是映射，一一对应，俗称字典。
数据结构_红黑树
ML_ZQ的博客
08-10 137
import org.omg.CORBA.BAD_CONTEXT; import java.util.ArrayList; public class MyRB&lt;K extends Comparable&lt;K&gt;, V&gt; { private static final boolean RED=true; private static final bo...
数据结构与算法分析Java3rd英文_数据结构与算法分析_
10-03
数据结构与算法分析是计算机科学中的核心领域，它关乎如何高效地存储和处理数据，以及设计和评估解决问题的计算过程。在Java环境下，理解和掌握这些概念对于任何IT专业人士来说都是至关重要的。以下是对标题和描述中...
数据结构和算法_201910101
08-03
数据结构是用来组织和存储数据的方式，常见的有数组、链表、栈、队列、集合、映射（哈希表）以及各种类型的树。数组是一种线性结构，它允许O(1)的随机访问，但在插入和删除元素时，平均时间复杂度为O(n)。链表，尤其...
《数据结构与算法 LeetCode刷题宝典V1.0》.pdf
05-03
其内容覆盖了数据结构与算法领域中最为关键的知识点，包括双指针技术、集合技术、字典技术、排序技术以及位运算技术。 首先，双指针技术是算法解题中经常用到的技巧之一，它可以有效地简化问题的复杂度，尤其是在...
数据结构之集合和映射
风间琉璃の博客
04-24 521
1. 集合（set） 不存放相同元素。 1.1 接口设计 因为集合中没有索引的概念，因此必须要给定一个遍历方法才能遍历该集合。 /** * @Description 集合接口 * @date 2022/4/23 14:26 */ public interface Set<E> { /** * 获取元素个数 * @return size */ int size(); /** * 判断是否为空 * @retu
数据结构入门-7-集合和映射
ifeng
04-27 370
集合 之前用二分搜索树实现了集合 现在使用链表实现集合LinkedList public class LinkedList<E> { private class Node{ public E e; public Node next; public Node(E e, Node next){ this.e...
玩转数据结构——第六章：集合和映射
犟驴的博客
10-02 965
集合(Set) 什么是集合？ 集合是承载元素的容器； 特点：每个元素只能存在一次 优点：去重 二分搜索树的添加操作add：不能盛放重复元素 是非常好的实现“集合”的底层数据结构 /** * 集合的接口 */ public interface Set&lt;E&gt; { void add(E e);//添加 &lt;——&lt;不能添加重复元素 void ...
面试题-02：动态数组_链表_二叉搜索树
你今天真好看呀
03-18 303
文章目录1、ArrayList底层怎么实现的？2、LinkedList底层怎么实现的？3、Arraylist 和 LinkedList的区别？4、Comparator与Comparable比较1. 树的概念和性质2. 二叉搜索树（包含Comparator与Comparable） 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。 阿里面试题1 阿里面试题2 阿里面试题3 ...
二叉搜索树（BST）及其实现
weixin_44396684的博客
11-26 508
二叉搜索树： 二叉搜索树（binary serach tree,BST）：对于树中的每一个结点，它的左子树中任意结点都小于该结点的值，而它的右子树中结点的值都大于该结点的值。（没有重复元素） 二叉搜索树的表示：可以使用链接结点的集合来表示二叉树，每个结点都包含一个数值和两个称为left和right的链接，分别引用左子结点和右子结点。 定义一个类实现结点 public class TreeNode<E> { protected E element; protected T
数据结构与算法分析（十三）--- 集合与映射 + Set/Map容器（C++11）
流云
01-16 2548
一、集合与映射 人们把一堆东西放到一起，就称之为集合了。一般来讲，集合是具有某种特性的事物的整体，或是一些确认对象的汇集，构成集合的事物或对象称作元素或是成员。集合的元素可以是任何事物，集合具有无序性、互异性、确定性等特性。 在数学上，我们可以把映射看作是集合与集合之间的一种对应关系，比如函数实际上就是数的集合到数的集合之间的映射关系。计算机更擅长处理数字编号，我们的大脑更擅长处理概念词汇，因此我们经常需要通过某个关键词key来查询一组数据的信息value，于是就把这种映射关系抽象为一个数据结构：键值对。
恋上数据结构与算法第一季笔记（三）—— 平衡搜索二叉树
JohnnyLin
05-11 129
平衡 理想平衡 改进 平衡二叉搜索树 AVL 树 平衡对比 AVLTree 继承结构 添加导致的失衡 右旋转 左旋转 LR —— RR左旋，LL右旋 AVLTree package trees; public class AVLTree<E> extends BST<E> { } //默认只有无参的构造方法 AVLTree<Integer> avl = new AVLTree<>(); 添加了以下构造方法
数据结构与算法学习笔记：二叉搜索树(下)
baidu_41388533的博客
07-18 253
写在前面：记录学习《恋上数据结构与算法》的过程。 课程链接地址：https://ke.qq.com/course/385223 目录 二叉树的遍历（适用于所有二叉树） 前序遍历 中序遍历 后序遍历 层序遍历 设计遍历接口 增强遍历接口 树状打印二叉树 遍历的应用 计算二叉树的高度 完全二叉树的判断 翻转二叉树 根据遍历结果重构二叉树 前驱节点（Predecessor） 后继节点（successor） 删除节点 - 叶子节点 删除节点 - 度为1的节点 删除节点 - 度为
探索数据结构：集合、映射与列表的实战应用
在本篇文章中，我们深入探讨了算法与数据结构的基础概念，特别是集合、映射和列表，以及它们在编程中的重要性。文章以Python为例，通过处理一个名为"txt.txt"的文本文件，展示了如何利用这些数据结构来理解数据类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值