数据结构实现 5.1：映射_基于二分搜索树实现（C++版）

最新推荐文章于 2025-01-16 21:17:59 发布
原创 最新推荐文章于 2025-01-16 21:17:59 发布 · 604 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#映射 #二分搜索树

本文介绍了如何利用二分搜索树实现映射数据结构，详细阐述了映射的基本操作，包括增加、删除、修改和查找，以及算法复杂度分析。并展示了完整的C++代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

数据结构实现 5.1：映射_基于二分搜索树实现（C++版）

1. 概念及基本框架

映射 是一种高级数据结构，其实现方法也不唯一，但存储上使用 链式存储（即内存的物理空间是不连续的）。这一节我们通过 二分搜索树 来实现映射这种数据结构。

映射
映射 的基本特性：
1.映射内元素包含 键（key） 和 值（value） ，而且一一对应。
2.映射内的元素的键 不能重复 。
注：有些映射（多重映射）中元素的键也可以重复。
显然，二分搜索树满足映射的特性，所以我们尝试利用二分搜索树来实现映射。但是，在 3.1 中实现的二分搜索树结点只有一个数据，所以我们需要从底层进行一些改进去适应映射这一数据结构。首先来定义树的结点类：

template <class K, class V>
class MapBSTNode{
public:
	MapBSTNode(K key = NULL, V value = NULL, MapBSTNode<K, V> *left = NULL, MapBSTNode<K, V> *right = NULL){
		m_key = key;
		m_value = value;
		this->left = left;
		this->right = right;
	}
public:
	K m_key;
	V m_value;
	MapBSTNode<K, V> *left;
	MapBSTNode<K, V> *right;
};

这个结点类的内部也显式的给出了构造函数，下面通过结点类来创建一棵二叉树。这个过程和 3.1 中二分搜索树的实现过程类似，所以不再赘述，如有需要可参看 3.1 。

template <class K, class V>
class MapBST{
public:
	MapBST(){
		root = NULL;
	}
	...
private:
	MapBSTNode<K, V> *root;
	int m_size;
};

为了满足映射操作的需求，我为这个类定义了几个接口函数，实现方法与 3.1 类似，所以同样不再赘述。

template <class K, class V>
class MapBST{
public:
	...
	int size(){
		return m_size;
	}
	bool isEmpty(){
		return root == NULL;
	}
	//增加操作
	void add(K key, V value){
		root = add(root, key, value);
	}
	//删除操作
	V remove(K key){
		V res = get(key);
		root = remove(root, key);
		return res;
	}
	//修改操作
	void set(K key, V value){
		MapBSTNode<K, V> *node = root;
		while (node){
			if (key == node->m_key){
				node->m_value = value;
				return;
			}
			else if (key < node->m_key){
				node = node->left;
			}
			else{
				node = node->right;
			}
		}
		cout << "不存在" << key << '!' << endl;
		return;
	}
	//查找操作
	V get(K key){
		MapBSTNode<K, V> *node = root;
		while (node){
			if (key == node->m_key){
				return node->m_value;
			}
			else if (key < node->m_key){
				node = node->left;
			}
			else{
				node = node->right;
			}
		}
		cout << "不存在" << key << '!' << endl;
		return NULL;
	}
	bool contains(K key){
		return contains(root, key);
	}
private:
	MapBSTNode<K, V>* add(MapBSTNode<K, V> *node, K key, V value){
		if (node == NULL){
			m_size++;
			return new MapBSTNode<K, V>(key, value);
		}
		else if (key < node->m_key){
			node->left = add(node->left, key, value);
		}
		else if (key > node->m_key){
			node->right = add(node->right, key, value);
		}
		return node;
	}
	MapBSTNode<K, V>* remove(MapBSTNode<K, V> *node, K key){
		if (node == NULL){
			return node;
		}
		if (key < node->m_key){
			node->left = remove(node->left, key);
		}
		else if (key > node->m_key){
			node->right = remove(node->right, key);
		}
		else if (key == node->m_key){
			if (node->left == NULL){
				MapBSTNode<K, V> *rightNode = node->right;
				delete node;
				m_size--;
				return rightNode;
			}
			else if (node->right == NULL){
				MapBSTNode<K, V> *leftNode = node->left;
				delete node;
				m_size--;
				return leftNode;
			}
			else{
				MapBSTNode<K, V> *minNode = node->right;
				for (; minNode->left; minNode = minNode->left);
				node->m_key = minNode->m_key;
				node->right = remove(node->right, minNode->m_key);
				return node;
			}
		}
		return node;
	}
	bool contains(MapBSTNode<K, V> *node, K key){
		if (node == NULL){
			return false;
		}
		if (key == node->m_key){
			return true;
		}
		else if (key < node->m_key){
			return contains(node->left, key);
		}
		else{
			return contains(node->right, key);
		}
	}
	...
};

有了改进版的二分搜索树，我们就可以利用一个由 纯虚函数 构成的 抽象类 作为一个接口来定义这些操作。具体代码如下：

template <class K, class V>
class Map{
public:
	virtual int size() = 0;
	virtual bool isEmpty() = 0;
	//增加操作
	virtual void add(K key, V value) = 0;
	//删除操作
	virtual V remove(K key) = 0;
	//修改操作
	virtual void set(K key, V value) = 0;
	//查找操作
	virtual bool contains(K key) = 0;
	virtual V get(K key) = 0;
};

下面只需要通过继承 抽象类，并且重写 纯虚函数 ，就可以完成 映射 的实现。映射类的框架如下：

template <class K, class V>
class BSTMap : public Map<K, V>{
	...
private:
	MapBST<K, V> bst;
};

这里为了避免重复设计就可以兼容更多数据类型，引入了 泛型 ，即 模板 的概念。（模板的关键字是 class 或 typename）
这里的 bst 表示一棵 二分搜索树 ，同样，为了保护数据，变量设置为 private 。
注：这里没有显式的给出构造函数，因为子类中除了二分搜索树对象之外没有特别需要初始化的东西。编译器会默认先调用 二分搜索树 类（即父类）的构造函数，再去调用 映射 类（即子类）的构造函数。
实现了前面的程序之后，接下来就是一个映射的增、删、改、查以及一些其他基本操作，接下来利用代码去实现。

2. 基本操作程序实现

2.1 增加操作

template <class K, class V>
class BSTMap : public Map<K, V>{
public:
	...
	//增加操作
	void add(K key, V value){
		bst.add(key, value);
	}
	...
};

直接调用二分搜索树的增加操作。（因为二分搜索树中的元素本来就不重复）

2.2 删除操作

template <class K, class V>
class BSTMap : public Map<K, V>{
public:
	...
	//删除操作
	V remove(K key){
		return bst.remove(key);
	}
	...
};

直接调用二分搜索树的删除操作。

2.3 修改操作

template <class K, class V>
class BSTMap : public Map<K, V>{
public:
	...
	//修改操作
	void set(K key, V value){
		bst.set(key, value);
	}
	...
};

2.4 查找操作

template <class K, class V>
class BSTMap : public Map<K, V>{
public:
	...
	//查找操作
	bool contains(K key){
		return bst.contains(key);
	}
	V get(K key){
		return bst.get(key);
	}
	...
};

2.5 其他操作

映射还有一些其他的操作，包括 映射大小 的查询等操作。

template <class K, class V>
class BSTMap : public Map<K, V>{
public:
	int size(){
		return bst.size();
	}
	bool isEmpty(){
		return bst.isEmpty();
	}
	...
};

3. 算法复杂度分析

因为映射操作直接调用了二分搜索树的操作，所以其操作的时间复杂度和二分搜索树相同。

3.1 增加操作

函数最坏复杂度平均复杂度
addO(n)O(logn)

3.2 删除操作

函数最坏复杂度平均复杂度
removeO(n)O(logn)

3.3 修改操作

函数最坏复杂度平均复杂度
setO(n)O(logn)

3.4 查找操作

函数最坏复杂度平均复杂度
containsO(n)O(logn)
getO(n)O(logn)

总体情况：

操作时间复杂度
增O(logn)
删O(logn)
改O(logn)
查O(logn)

很显然，利用二分搜索树很容易实现映射这一高级数据结构。

4. 完整代码

程序完整代码（这里使用了头文件的形式来实现类）如下。
二分搜索树 类代码：

#ifndef __MAPBST_H__
#define __MAPBST_H__

template <class K, class V>
class MapBSTNode{
public:
	MapBSTNode(K key = NULL, V value = NULL, MapBSTNode<K, V> *left = NULL, MapBSTNode<K, V> *right = NULL){
		m_key = key;
		m_value = value;
		this->left = left;
		this->right = right;
	}
public:
	K m_key;
	V m_value;
	MapBSTNode<K, V> *left;
	MapBSTNode<K, V> *right;
};
template <class K, class V>
class MapBST{
public:
	MapBST(){
		root = NULL;
	}
	int size(){
		return m_size;
	}
	bool isEmpty(){
		return root == NULL;
	}
	//增加操作
	void add(K key, V value){
		root = add(root, key, value);
	}
	//删除操作
	V remove(K key){
		V res = get(key);
		root = remove(root, key);
		return res;
	}
	//修改操作
	void set(K key, V value){
		MapBSTNode<K, V> *node = root;
		while (node){
			if (key == node->m_key){
				node->m_value = value;
				return;
			}
			else if (key < node->m_key){
				node = node->left;
			}
			else{
				node = node->right;
			}
		}
		cout << "不存在" << key << '!' << endl;
		return;
	}
	//查找操作
	V get(K key){
		MapBSTNode<K, V> *node = root;
		while (node){
			if (key == node->m_key){
				return node->m_value;
			}
			else if (key < node->m_key){
				node = node->left;
			}
			else{
				node = node->right;
			}
		}
		cout << "不存在" << key << '!' << endl;
		return NULL;
	}
	bool contains(K key){
		return contains(root, key);
	}
private:
	MapBSTNode<K, V>* add(MapBSTNode<K, V> *node, K key, V value){
		if (node == NULL){
			m_size++;
			return new MapBSTNode<K, V>(key, value);
		}
		else if (key < node->m_key){
			node->left = add(node->left, key, value);
		}
		else if (key > node->m_key){
			node->right = add(node->right, key, value);
		}
		return node;
	}
	MapBSTNode<K, V>* remove(MapBSTNode<K, V> *node, K key){
		if (node == NULL){
			return node;
		}
		if (key < node->m_key){
			node->left = remove(node->left, key);
		}
		else if (key > node->m_key){
			node->right = remove(node->right, key);
		}
		else if (key == node->m_key){
			if (node->left == NULL){
				MapBSTNode<K, V> *rightNode = node->right;
				delete node;
				m_size--;
				return rightNode;
			}
			else if (node->right == NULL){
				MapBSTNode<K, V> *leftNode = node->left;
				delete node;
				m_size--;
				return leftNode;
			}
			else{
				MapBSTNode<K, V> *minNode = node->right;
				for (; minNode->left; minNode = minNode->left);
				node->m_key = minNode->m_key;
				node->right = remove(node->right, minNode->m_key);
				return node;
			}
		}
		return node;
	}
	bool contains(MapBSTNode<K, V> *node, K key){
		if (node == NULL){
			return false;
		}
		if (key == node->m_key){
			return true;
		}
		else if (key < node->m_key){
			return contains(node->left, key);
		}
		else{
			return contains(node->right, key);
		}
	}
private:
	MapBSTNode<K, V> *root;
	int m_size;
};

#endif

抽象类 接口代码：

#ifndef __MAP_H__
#define __MAP_H__

template <class K, class V>
class Map{
public:
	virtual int size() = 0;
	virtual bool isEmpty() = 0;
	//增加操作
	virtual void add(K key, V value) = 0;
	//删除操作
	virtual V remove(K key) = 0;
	//修改操作
	virtual void set(K key, V value) = 0;
	//查找操作
	virtual bool contains(K key) = 0;
	virtual V get(K key) = 0;
};

#endif

映射类 代码：

#ifndef __BSTMAP_H__
#define __BSTMAP_H__

#include "Map.h"
#include "MapBST.h"

template <class K, class V>
class BSTMap : public Map<K, V>{
public:
	int size(){
		return bst.size();
	}
	bool isEmpty(){
		return bst.isEmpty();
	}
	//增加操作
	void add(K key, V value){
		bst.add(key, value);
	}
	//删除操作
	V remove(K key){
		return bst.remove(key);
	}
	//修改操作
	void set(K key, V value){
		bst.set(key, value);
	}
	//查找操作
	bool contains(K key){
		return bst.contains(key);
	}
	V get(K key){
		return bst.get(key);
	}
private:
	MapBST<K, V> bst;
};

#endif
30、数据结构与C++实现：深度解析与应用
sss66的博客
05-24 17
本文深入解析了数据结构的重要性及其在C++中的实现方式，涵盖了抽象数据类型（ADT）、数组、指针、链表、栈、队列、树、图等多种基础和高级数据结构。同时介绍了字符串处理、常见排序与搜索算法，并探讨了数据结构在文件系统、社交网络和数据库索引等实际场景中的应用。通过理论与代码示例结合，帮助开发者提升程序设计能力和性能优化水平。
31、探索数据结构与C++实现：从基础到高级
最新发布
sss66的博客
05-25 14
本文深入探讨了计算机科学中的核心概念——数据结构，并通过C++语言实现这些结构。从基础的抽象数据类型和算法设计，到数组、指针、链表、栈、队列等基本数据结构，再到树、图、哈希表等高级结构，内容详尽且循序渐进。此外，还介绍了常见的排序与搜索算法以及递归技术。无论您是初学者还是有经验的开发者，都能从中获得宝贵的知识和实用技巧。
树的镜面映射
melanieecd的博客
05-03 2013
poj 4082 http://bailian.openjudge.cn/practice/4082/ 考察： 1） 通过伪满二叉树还原树 2） 层次遍历树的镜面映射总时间限制: 1000ms 内存限制: 65536kB 描述我们在输入输出一棵树的时候，常常会把树转换成对应的二叉树，而且对该二叉树中只有单个子结点的分支结点补充一个虚子结点“$”，形成“伪满二叉树”。例如，对下图左边的树，得
数据结构实现 5.2：映射_基于链表实现（C++版）
九霄星河的博客
11-13 706
数据结构实现 5.2：映射_基于链表实现（C++版）1. 概念及基本框架2. 基本操作程序实现2.1 增加操作2.2 删除操作2.3 修改操作2.4 查找操作2.5 其他操作3. 算法复杂度分析3.1 增加操作3.2 删除操作3.3 修改操作3.4 查找操作4. 完整代码 1. 概念及基本框架 . 在 5.1 中我们通过 二分搜索树 来实现了映射，这一节我们通过 链表 来实现映射。 映射 的基本...
数据结构实现 10.2：映射_基于AVL树实现（C++版）
九霄星河的博客
11-26 732
数据结构实现 10.2：映射_基于AVL树实现（C++版）1. 概念及基本框架2. 基本操作程序实现2.1 增加操作2.2 删除操作2.3 修改操作2.4 查找操作2.5 其他操作3. 算法复杂度分析3.1 增加操作3.2 删除操作3.3 修改操作3.4 查找操作4. 完整代码 1. 概念及基本框架 映射 是一种高级数据结构，其实现方法也不唯一，但存储上使用 链式存储（即内存的物理空间是不连续的）...
数据结构——二分搜索树的实现
jinyu_mobao的博客
02-10 204
public class BST<E extends Comparable<E>> { private class Node{ public E e; public Node left,right; //构造函数，让用户传入的参数e等于这里的e public Node(E e){ this.e=e; left=null; right=n...
数据结构实现 4.1：集合_基于二分搜索树实现（C++版）
九霄星河的博客
11-13 561
数据结构实现 4.1：集合_基于树实现（C++版）1. 概念及基本框架2. 基本操作程序实现2.1 增加操作2.2 删除操作2.3 查找操作2.4 其他操作3. 算法复杂度分析3.1 增加操作3.2 删除操作3.3 查找操作4. 完整代码 1. 概念及基本框架 集合 是一种高级数据结构，其实现方法也不唯一，但存储上使用 链式存储（即内存的物理空间是不连续的）。这一节我们通过 二分搜索树 来实现集合...
C++17新容器解析：std::flat_map与std::flat_set的创新应用
![C++17新容器解析：std::flat_...首先，介绍了std::flat_map的数据结构、操作细节和与std::map的性能比较，随后转向std::flat_set，分析了它的数据结构、操作详解及性能优化案例。文章还探讨了这些新容器在标准库之外
数据结构、算法与应用：C++语言描述（原书第2版）第二部分
12-06
5.1 数据对象和数据结构 5.2 线性表数据结构 5.2.1 抽象数据类型linearList 5.2.2 抽象类linearList 5.3 数组描述 5.3.1 描述 5.3.2 变长一维数组 5.3.3 类arrayList 5.3.4 C++迭代器 5.3.5 arrayList的一个迭代器 ...
C++数据结构和算法2 栈 双端 队列 冒泡选择插入归并快排 二三分查找 二叉树 二叉搜索树 贪婪 分治 动态规划_双端合并 算法
2501_90225825的博客
01-16 746
霍夫曼编码使用变长编码表对源符号（如文件中的一个字母）进行编码，其中变长编码表是通过一种评估来源符号出现机率的方法得到的，出现机率高的字母使用较短的编码，反之出现机率低的则使用较长的编码，这便使编码之后的字符串的平均长度、期望值降低，从而达到无损压缩数据的目的。// 最小值，一个BST的最左叶子节点的key值就是BST所有key值中最小的,不停递归左子树，直到无左子树时。// 最大值，一个BST的最右叶子节点的key值就是BST所有key值中最大的,不停递归右子树，直到无右子树时。
数据结构实现（C++版）
11-28
内含资源如下： 1.基本数据结构 1.1.Array ........... 动态数组 1.2.LinkedList ... 链表 1.3.BST .............. 二分搜索树 1.4.MapBST ..... 二分搜索树（用于实现映射） 1.5.AVLTree ...... AVL树 2.接口 2.1.Queue ........... 队列接口 2.2.Stack .............. 栈接口 2.3.Set .................. 集合接口 2.4.Map ............... 映射接口 2.5.Merger .......... 自定义函数接口 2.6.UnionFind ..... 并查集接口 3.高级数据结构 3.1.ArrayQueue .......................... 队列_基于动态数组实现 3.2.LinkedListQueue .................. 队列__基于链表实现 3.3.LoopQueue ........................... 循环队列_基于动态数组实现 3.4.PriorityQueue ....................... 优先队列_基于最大二叉堆实现 3.5.ArrayPriorityQueue ............. 优先队列_基于动态数组实现 3.6.LinkedListPriorityQueue ..... 优先队列_基于链表实现 3.7.ArrayStack ............................. 栈_基于动态数组实现 3.8.LinkedListStack ..................... 栈_基于链表实现 3.9.BSTSet ..................................... 集合_基于二分搜索树实现 3.10.LinkedListSet ....................... 集合_基于链表实现 3.11.BSTMap ................................ 映射_基于二分搜索树实现 3.12.AVLTreeMap ....................... 映射_ 基于AVL树实现 3.13.LinkedListMap .................... 映射_基于链表实现 3.14.MaxHeap ............................. 最大二叉堆 3.15.SegmentTree ...................... 线段树 3.16.Trie ......................................... 字典树 3.17.QuickFind ............................ 并查集_基于数组实现 3.18.QuickUnion ......................... 并查集_基于树思想实现
《数据结构——C++实现》（第二版）课本源代码
04-25
《数据结构——C++实现》（第二版）课本源代码，很全很给力
数据结构（9）：基于二分搜索树和链表的映射实现
小蚯蚓的博客
12-18 270
1.映射定义 存储键值对的数据结构，实现根据键，查找值的功能。 2.映射实现功能 （1）void add(K,V) （2）V remove(K) （3）boolean contains(K) （4）V get(K) （5）void set(K,V) （6）int getSize() （7）boolean isEmpty() （8）映射接口实现 public interfac...
数据结构笔记（C++实现）
qq_36028321的博客
05-13 853
数据结构笔记（大话数据结构）**序**1、数据结构绪论基本术语2、算法2.1、算法的特性2.2、算法的设计要求 序 这是我的第一篇在网络上记载的笔记，实是记录在学习过程中的一些心得体会。毕竟逐渐的发现学习的过程中没有记录，即使当时认真学过，一段时间之后就会变成过眼云烟。本科学了几年机械，从无感到热爱再到这个专业成为别人口中的笑柄。回头想想，其实错不在某个专业学什么，也不在这个专业下的学生，只是风向不同而已。在此之前，已经学习过吴恩达的ml和黑马的c++，虽然课是听完了，但也就大致摸索到个概念而已。并不是说这
数据结构之映射
qq_24095055的博客
04-06 800
数据结构之映射映射Map接口定义基于链表的映射实现基于二分搜索树的映射实现映射的复杂度分析有序映射和无序映射多重映射 映射 映射概念的实现： dict key value 字典 单词 释义 名册 身份证号 人 车辆管理 车牌号 车 数据库 id 信息 词频统计 单词 频率 存储（键，值）数据对的数据结构（Key，Value） 根据键（Key），寻找值（Valu...
数据结构-映射
听雪楼
10-09 714
存储键值(Key, Value)数据对的数据结构 根据键(Key),寻找值(Value) 非常容易使用链表或二分搜索树进行实现 Java中的HashMap和TreeMap底层分别基于哈希表和红黑树进行实现 代码实现 : package map; /** * 使用二分搜索树实现Map * @author 七夜雪 * * @param &lt;K&gt; * @param &lt;V&...
数据结构：映射
weixin_44333294的博客
12-20 1462
需要映射数据结构一般是为了根据键来快速寻找值，键充当索引 删除元素时，键充当索引，可以不考虑键对应的值是什么，只要删除指定键对应的数据，相应的值也删除了 查找是否存在某个数据，也可以直接根据键来查找，类似于查字典，只要知道某个单词是否存在，不去管单词的释义是什么；类似查车牌号是否注册，不去管车辆的具体信息 使用get拿到具体信息 set给定键和新的值的信息，更新键对应的值，而不是传入新的键和值，不然就和add的作用重合了 public class LinkedListMap<K,V>
数据结构|映射
weixin_43340821的博客
07-28 338
查找学生信息|清华考研复试 描述 输入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!
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

九霄星河

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

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

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

打赏作者

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

抵扣说明：

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

余额充值