数据结构与算法之映射

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

目录

(一) 定义

映射Map: 存储(键, 值)数据对的数据结构(Key, Value), 我们可以根据键(Key)来寻找值(Value), 且key在映射中是唯一的.实现映射的方式多种多样, 在JAVA语言表现中, 会将映射定义成一个接口, 提供映射对应的操作的抽象方法.

/**
 * 自定义映射抽象类Map
 * 
 * @author Administrator
 *
 * @param <K>
 * @param <V>
 */
public interface Map<K, V> {

	/**
	 * 向映射中添加键值对数据(Key键不允许重复)
	 * 
	 * @param key
	 * @param value
	 */
	void add(K key, V value);
	
	/**
	 * 从映射中删除键为key的数据
	 * 
	 * @param key
	 * @return
	 */
	V remove(K key);
	
	/**
	 * 映射中是否存在key
	 * 
	 * @param key
	 * @return
	 */
	boolean contains(K key);
	
	/**
	 * 从映射中取出key键 对应的value值
	 * 
	 * @param key
	 * @return
	 */
	V get(K key);
	
	/**
	 * 修改映射中key对应的value值
	 * 
	 * @param key
	 * @param value
	 */
	void set(K key, V value);
	
	/**
	 * 映射中键值对个数
	 * 
	 * @return
	 */
	int getSize();
	
	/**
	 * 映射是否为空
	 * 
	 * @return
	 */
	boolean isEmpty();
}

(二) 自定义映射

1.基于链表的映射实现
public class LinkedListMap<K, V> implements Map<K, V> {

	/**
	 * 节点内部类: 可以单独定义出来, 但用户无需关注映射底层实现, 因此定义成LinkedListMap的内部类
	 * 
	 * @author Administrator
	 *
	 */
	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;
		}
		
		@SuppressWarnings("unused")
		public Node(K key) {
			this(key, null, null);
		}
		
		public Node() {
			this(null, null, null);
		}
		
		@Override
		public String toString() {
			return key.toString() + " : " + value.toString();
		}
	}
	
	/**
	 * 虚拟头部节点: 存储的数据为Null, 下一个节点next也为Null
	 */
	private Node dummyHead;

	/**
	 * 映射键值对个数
	 */
	private int size;
	
	public LinkedListMap() {
		this.dummyHead = new Node();
		this.size = 0;
	}
	
	@Override
	public int getSize() {
		return this.size;
	}

	@Override
	public boolean isEmpty() {
		return this.size == 0;
	}
	
	/**
	 * 获取key对应的结点
	 * 
	 * @param key
	 * @return
	 */
	private Node getNode(K key) {
		Node cur = this.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 res = getNode(key);
		return res == null ? null : res.value;
	}
	
	@Override
	public void add(K key, V value) {
		Node node = getNode(key);
		if (node == null) {
			// key键在映射中不存在, 添加新的结点
			dummyHead.next = new Node(key, value, dummyHead.next);
			size++;
		} else {
			// key键在映射中存在, 修改key所在的结点对应的值为 value 
			node.value = value;
		}
	}
	
	@Override
	public void set(K key, V value) {
		Node node = getNode(key);
		if (node == null) {
			throw new IllegalArgumentException(key + " doesn't exist!");
		} 
		node.value = value;
	}

	@Override
	public V remove(K key) {
		Node prev = this.dummyHead;
		while (prev.next != null) {
			if (prev.next.key.equals(key)) {
				V value = prev.next.value;
				prev.next = prev.next.next;
				size--;
				return value;
			}
			prev = prev.next;
		}
		return null;
	}

}
2.基于二分搜索树的映射实现
public class BSTMap<K extends Comparable<K>, V> implements Map<K, V> {

	/**
	 * 节点内部类: 可以单独定义出来, 但用户无需关注映射底层实现, 因此定义成BSTMap的内部类
	 * 
	 * @author Administrator
	 *
	 */
	private class Node {
		
		/**
		 * 存储映射的键 
		 */
		public K key;
		
		/**
		 * 存储映射的值 
		 */
		public V value;
		
		/**
		 * 左子树
		 */
		public Node left;
		
		/**
		 * 右子树
		 */
		public Node right;
		
		public Node(K key, V value) {
			this.key = key;
			this.value = value;
			this.left = null;
			this.right = null;
		}
	}
	
	/**
	 * 根结点
	 */
	private Node root;
	
	/**
	 * 映射中键值对个数
	 */
	private int size;
	
	public BSTMap() {
		this.root = null;
		this.size = 0;
	}
	
	@Override
	public int getSize() {
		return this.size;
	}

	@Override
	public boolean isEmpty() {
		return this.size == 0;
	}
	
	/**
	 * 向映射中添加键值对key-value(Key键不允许重复)
	 */
	@Override
	public void add(K key, V value) {
		this.root = add(this.root, key, value);
	}
	
	/**
	 * 向以node为根的二分搜索树中插入键值对key-value, 返回插入新节点后二分搜索树的跟
	 * 
	 * @param node
	 * @param key
	 * @param value
	 * @return
	 */
	private Node add(Node node, K key, V value) {
		if (node == null) {
			size++;
			return new Node(key, value);
		}
		// 二分搜索树中存在插入key, 修改key对应的value
		if (node.key.compareTo(key) == 0) {
			node.value = value;
		} else if (node.key.compareTo(key) < 0) {
			node.right = add(node.right, key, value); 
		} else if (node.key.compareTo(key) > 0) {
			node.left = add(node.left, key, value); 
		}
		return node;
	}
	
	/**
	 * 返回以node为根结点定的二分搜索树中, key所对应的结点
	 * 
	 * @param key
	 * @return
	 */
	private Node getNode(Node node, K key) {
		if (node == null) {
			return null;
		} 
		if (node.key.compareTo(key) == 0) {
			return node;
		} else if (node.key.compareTo(key) < 0) {
			return getNode(node.right, key);
		} else {
			return getNode(node.left, 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为根的二分搜索树的最小值所在的结点
	 * 
	 * @param node
	 * @return
	 */
	private Node minimum(Node node) {
		if (node.left != null) {
			return node.left;
		}
		return minimum(node.left);
	}
	
	/**
	 * 向以node为根的二分搜索树中删除最小元素, 返回删除最小元素节点后二分搜索树的跟
	 * 
	 * @param node
	 * @return
	 */
	private Node removeMin(Node node) {
		if (node.left == null) {
			Node delNode = node.right;
			node.right = null;
			size--;
			return delNode;
		}
		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;
	}
	
	/**
	 * 删除以node为根的二分搜索树中键为key的结点, 返回删除节点后新的二分搜索树的跟
	 * 
	 * @param node
	 * @param key
	 * @return
	 */
	private Node remove(Node node, K key) {
		if (node == null) {
			return null;
		} 
		if (node.key.compareTo(key) == 0) {
			
			if (node.left == null) {
				Node delNode = node.right;
				node.right = null;
				size--;
				return delNode;
			}
			
			if (node.right == null) {
				Node delNode = node.left;
				node.left = null;
				size--;
				return delNode;
			}
			Node replaceNode = minimum(node.right);
			replaceNode.right = removeMin(node.right);
			replaceNode.left = node.left;
			return replaceNode;
		} else if (node.key.compareTo(key) < 0) {
			node.right = remove(node.right, key);
		} else {
			node.left = remove(node.left, key);
		}
		return node;
	}
}

(三) 时间复杂度分析

add(e)方法为了保证映射存储的key不重复, 内部调用了getNode(k) 方法

 LinkedListMapBSTMap平均最差(链表)
add(k, v)O(n)O(h)O(logn)O(n)
remove(k)O(n)O(h)O(logn)O(n)
contains(k)O(n)O(h)O(logn)O(n)
get(k)O(n)O(h)O(logn)O(n)
set(k, v)O(n)O(h)O(logn)O(n)
又十七
关注
专栏目录
数据结构：映射.pdf
07-11
数据结构：映射 数据结构：映射 我们通常所⽤的map其实就是⼀棵红⿊树，如果有平衡树问题能够⽤它来解决⼀定要⽤，不要⼿写了，因为红⿊树的效率是⾮常棒的 先看⼏个定义： map<string,int> m1; map<string,map<string,int> >m2; multiset<string> s1; multimap<string,string> m3; 其中m1就是⼀个关联数组，为了模拟普通哈希表 (这⾥的所有的都是⽤红⿊树实现的，如果你想⽤哈希表实现，请直接把map替换成hash_map，在空间⾜够的情况下) 另外，如果有C++11⽤，⼀定要⽤unordered_map，别⽤hash_map了 hash_map有⼀个专有的命名空间: using namespace __gnu_cxx; m2是⼆维哈希表 s1在之前介绍集合的时候没有提到，这⾥再提⼀下，这是允许有重复元素的STL集合，学名多级集合 m3就是⼀个多级映射，允许⼀个x对应多个y的情况，这样便于实现字典 我们⼀个⼀个介绍，s1就不介绍了，和set的⽤法完全⼀致 ⾸先是实现最简单的哈希表功能： string wo
数据结构：映射
weixin_44333294的博客
12-20 1315
需要映射数据结构一般是为了根据键来快速寻找值，键充当索引 删除元素时，键充当索引，可以不考虑键对应的值是什么，只要删除指定键对应的数据，相应的值也删除了 查找是否存在某个数据，也可以直接根据键来查找，类似于查字典，只要知道某个单词是否存在，不去管单词的释义是什么；类似查车牌号是否注册，不去管车辆的具体信息 使用get拿到具体信息 set给定键和新的值的信息，更新键对应的值，而不是传入新的键和值，不然就和add的作用重合了 public class LinkedListMap<K,V>
数据结构之映射
gao_zhennan的博客
11-19 563
一 映射 定义：存储（键Key，值Value）数据对的数据结构
数据结构-映射
听雪楼
10-09 663
存储键值(Key, Value)数据对的数据结构 根据键(Key),寻找值(Value) 非常容易使用链表或二分搜索树进行实现 Java中的HashMap和TreeMap底层分别基于哈希表和红黑树进行实现 代码实现 : package map; /** * 使用二分搜索树实现Map * @author 七夜雪 * * @param &lt;K&gt; * @param &lt;V&...
数据结构与算法代码详解JAVA版
08-26
在IT领域，数据结构与算法是编程基础的重要组成部分，它们直接影响到程序的效率和优化能力。本资源"数据结构与算法代码详解JAVA版"聚焦于使用Java语言来理解和实现这些核心概念。 首先，数据结构是组织和存储数据的...
数据结构与算法分析 C语言描述（原书第2版）课后习题参考答案
01-02
数据结构与算法分析是计算机科学中的核心课程，它主要研究如何高效地组织和管理数据，以便于进行快速的检索、插入、删除等操作。C语言因其底层特性，常被用于实现这些复杂的数据结构和算法，使得理解更加直观，性能...
go专业数据结构与算法高级
06-16
在编程领域，数据结构与算法是核心技术之一，尤其在Go语言这样的系统级编程语言中，对数据结构和算法的理解和运用至关重要。Go语言以其简洁、高效和并发特性受到广大开发者的喜爱，而深入掌握其数据结构和算法可以...
数据结构与算法.pdf
08-10
数据结构与算法是计算机科学的两大基础领域之一。数据结构关注的是数据的组织、存储和处理方式，而算法是解决特定问题的一系列操作步骤。C++作为一种高效且功能丰富的编程语言，常被用于实现各种数据结构和算法。 ...
Python cookbook(数据结构与算法)将多个映射合并为单个映射的方法
12-23
问题：在逻辑上将多个字典或映射合并为一个单独的映射结构，以此执行某些特定的操作，比如查找值或者检查键是否存在 解决方案：利用collections模块中的ChainMap类 ChainMap可接受多个映射然后在逻辑上使它们表现为...
纹理映射算法
01-03
使用OpenGL实现了针对简单3D物体的纹理映射算法，在VC++6.0中能够编译通过。
自组织映射算法分类数据
04-19
简单的自组织映射算法分类矩阵中的数据，使用matlab编写。
数据结构|映射
weixin_43340821的博客
07-28 263
查找学生信息|清华考研复试 描述 输入N个学生的信息，然后进行查询。 输入描述： 输入的第一行为N，即学生的个数(N<=1000) 接下来的N行包括N个学生的信息，信息格式如下： 01 李江 男 21 02 刘唐 男 23 03 张军 男 19 04 王娜 女 19 然后输入一个M(M<=10000),接下来会有M行，代表M次查询，每行输入一个学号，格式如下： 02 03 01 04 输出描述： 输出M行，每行包括一个对应于查询的学生的信息。 如果没有对应的学生信息，则输出“No Answer!
数据结构__映射MAP
ML_ZQ的博客
08-07 221
import java.util.ArrayList; import java.util.TreeMap; public class no350 { public int[] intersect(int[] nums1, int[] nums2) { TreeMap&lt;Integer,Integer&gt; trm = new TreeMap&lt;Integ...
算法映射技术
小柚子的博客
12-12 593
算法映射技术 将图像处理的算法转换为FPGA系统设计的过程为算法映射。 映射过程的首要目标便是确定系统设计的结构，在图像处理中常用的两种系统设计结构：流水线结构和并行阵列结构 1、流水线设计 （1）基本概念 流水线处理源自现代工业生产装配线上的流水作业，是指将待处理的任务分解为相对独立的、可以顺序执行的而又相互关联的一个个子任务。流水线处理是高速设计中的一个常用设计手段，如果某个设计的处理流程分为若干步骤，并且整个数据处理是“单流向”的，即没有反馈或者迭代运算，前一个步骤是输出是下一个步骤的输入，那么可以考
数据结构与算法笔记（4）映射和集合
DomMayer's paradox的博客
03-05 260
映射,集合（Map，Set） 哈希表&amp;哈希函数（HashTable&amp;Hash Function） 哈希函数 通过函数将某一元素放在数组的某个位置 哈希碰撞（Hash Collisions）：数组里某个位置有两个元素 解决哈希碰撞的方法，可以用拉链法，即将该位置用链表放置。 List vs Map vs Set HashMap vs TreeMap HashSet vs Tre...
数据结构学习之映射篇(Java)
A cold winter的博客
05-15 239
映射(Map): Map 是一种键-值对（key-value）集合，Map 集合中的每一个元素都包含一个键对象和一个值对象。其中，键对象不允许重复，而值对象可以重复，并且值对象还可以是 Map 类型的，就像数组中的元素还可以是数组一样。 Map接口： 增删改查 public interface Map<K,V> { //添加元素 void add(K key,V value); //删除元素 V remove(K key); //是否包含某元素
数据结构1.8 映射
m0_38125704的博客
08-22 158
1、映射：顾名思义，就是一个值对应到另外一个值，属于一对一形式，映射在生活中也有很多体现，类似与身份证号和人属于一对一的映射，车子和车牌也是映射，而在开发中，比如：数据库Id对应一条数据，也是属于映射。 官方一点的释义：储存数据结构，根据key对应value； 写一个基于链表的映射来练习一下原理 package com.study.map; /** * Created by Admin...
算法 从问题到方法的映射
程志伟的博客
03-12 525
任务示例 机器学习术语 典型方法 1.识别垃圾邮件 2.根据商品目录对商品分类 3.识别即将违约的贷款 4.将顾客指派到某个顾客类 分类：将已知标签指派给对象 决策树、朴素贝叶斯、逻辑回归、支持向量机   1.预测关键词广告的价值 2.估计贷款会拖欠的概率 3.预测营销活动将增加多少交易量或者销售量 回归：预测或者预报数值 线性回归、逻辑回归 1.发现被一起购买的商品 2...
前端面试必备：数据结构与算法解析
"该文档是关于前端面试中数据结构与算法类的知识点总结，涵盖了数据结构的基本概念，包括数据、数据元素、数据对象和数据结构的逻辑与物理结构，以及算法的基本概念，如算法特性、设计目标和复杂度分析。" 在前端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值