map类简单实现

最新推荐文章于 2021-08-13 15:08:09 发布
最新推荐文章于 2021-08-13 15:08:09 发布
阅读量353 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42486404/article/details/83795503
版权

迷宫问题提到过键值对查询，最坏情况查询效率是\Theta \left ( \log n \right )，总之比顺序查询快得多。

这次基于AVL树（3+4重构）实现map，以及其中序遍历的迭代器。

除了增删节点外，迭代器也是一大难点...之前没啥思路来着。大佬提示用栈作迭代器，其实对于动态存储的容器，随着容器元素的修改要维护额外的数据结构也不容易，最后还是中序遍历。

中序遍历好在按照键值升序排序的，重载迭代器自减运算之后也支持降序，一个迭代器可以对应好几棵树，说明迭代器不仅仅保存结点指针。换句话说迭代器end里除了空指针，还存储了树的指针。有树的指针就可以找到根节点，保证了自减后可以迭代到begin。

template<typename Type_key, typename Type_value>
struct _map {
	struct _pair {
		friend struct _map;
		const Type_key first;
		Type_value second;
	protected:
		int height;
		_pair *lchild, *rchild, *parent;
		_pair(const Type_key key, Type_value value, _pair *parent) :first(key), second(value), height(1), lchild(0), rchild(0), parent(parent) {}
		~_pair() {
			if (lchild) delete lchild;
			if (rchild) delete rchild;
		}
	};
private:
	int SIZE;
	_pair *root;
	/*获得孩子的高度*/
	void getheightbelow(_pair *p, int &l, int &r) {
		l = p->lchild ? p->lchild->height : 0;
		r = p->rchild ? p->rchild->height : 0;
	}
	/*通过孩子更新高度*/
	void updateheight(_pair *p) {
		int l, r;
		getheightbelow(p, l, r);
		p->height = 1 + (l > r ? l : r);
	}
	/*更新自己及祖先的高度*/
	void updateheightabove(_pair *p) {
		int l, r;
		while (p) {
			getheightbelow(p, l, r);
			p->height = 1 + (l > r ? l : r);
			p = p->parent;
		}
	}
	void balance(_pair *g) {
		_pair *p, *v, *gp;
		int l, r;
		while (g) {
			getheightbelow(g, l, r);
			if ((l - r) == 2 || (r - l) == 2) {
				/*g失衡，找到g的父亲*/
				gp = g->parent;
				if (l > r) {
					p = g->lchild;
					getheightbelow(p, l, r);
					if (l>r) {
						v = p->lchild;
						g = connect34(v, p, g, v->lchild, v->rchild, p->rchild, g->rchild);
					}
					else {
						v = p->rchild;
						g = connect34(p, v, g, p->lchild, v->lchild, v->rchild, g->rchild);
					}
				}
				else {
					p = g->rchild;
					getheightbelow(p, l, r);
					if (r>l) {
						v = p->rchild;
						g = connect34(g, p, v, g->lchild, p->lchild, v->lchild, v->rchild);
					}
					else {
						v = p->lchild;
						g = connect34(g, v, p, g->lchild, v->lchild, v->rchild, p->rchild);
					}
				}
				g->parent = gp;
				/*若旧g的父亲存在，新g成为旧g父亲的孩子*/
				if (gp) {
					if (g->first < gp->first) gp->lchild = g;
					else gp->rchild = g;
				}
				else root = g;
				updateheightabove(g);
			}
			g = g->parent;
		}
	}
	/*3+4重构返回新g结点*/
	_pair *connect34(_pair *a, _pair *b, _pair *c, _pair *T0, _pair *T1, _pair *T2, _pair *T3) {
		a->lchild = T0; if (T0) T0->parent = a;
		a->rchild = T1; if (T1) T1->parent = a;
		updateheight(a);
		c->lchild = T2; if (T2) T2->parent = c;
		c->rchild = T3; if (T3) T3->parent = c;
		updateheight(c);
		b->lchild = a; a->parent = b;
		b->rchild = c; c->parent = b;
		return b;
	}
	/*判断np应该是祖先的左还是右孩子，并连接np和祖先，np不一定存在*/
	void lor(_pair *parent, _pair *np,const Type_key key) {
		if (parent) {
			if (key < parent->first) parent->lchild = np;
			else parent->rchild = np;
		}
		else root = np;
		if (np) np->parent = parent;
	}
	/*删除p结点*/
	void remove(_pair *p) {
		_pair *parent = p->parent, *np = 0;
		/*当p有左右孩子*/
		if (p->lchild&&p->rchild) {
			_pair *npp = 0;
			np = p->lchild;
			/*找到左边最右的孩子作为被替换结点np*/
			while (np->rchild) np = np->rchild;
			/*找到被替换节点的父亲npp*/
			npp = np->parent;
			/*若被替换节点的父亲是要被删除的结点，直接拿np替换p*/
			if (npp == p) {
				lor(parent, np, p->first);
				p->rchild->parent = np;
				np->rchild = p->rchild;
				updateheightabove(np);
				balance(np);
			}
			else {
				/*若被替换的结点np有左孩子，把np的左孩子作为npp的右孩子*/
				if (np->lchild) {
					npp->rchild = np->lchild;
					np->lchild->parent = npp;
				}
				p->lchild->parent = np;
				p->rchild->parent = np;
				np->lchild = p->lchild;
				np->rchild = p->rchild;
				npp->rchild = 0;
				lor(parent, np, p->first);
				updateheightabove(npp);
				balance(npp);
			}
		}
		else {
			/*当p只有一个孩子，直接用它的孩子替换，若没有孩子,np为空*/
			if (p->lchild) np = p->lchild;
			else if (p->rchild) np = p->rchild;
			lor(parent, np, p->first);
			updateheightabove(parent);
			balance(parent);
		}
		p->lchild = 0, p->rchild = 0;
		delete p;
		SIZE--;
		return;
	}
public:
	_map() :root(0), SIZE(0) {}
	~_map() { if (root) delete root; }
	void clear() { if (root) delete root; SIZE = 0; root = 0; }
	int size() { return SIZE; }
	struct _iterator {
		_map *m;
		_pair *p;
		_iterator(_map *m = 0, _pair *p = 0) :m(m), p(p) {}
		_pair *operator->() { return p; }
		_iterator operator++(int) {
			_pair *pre = p;
			if (p == 0) throw "invalid index\n";
			/*当p有右孩子，找到最左的右孩子*/
			if (p->rchild) {
				p = p->rchild;
				while (p->lchild) p = p->lchild;
			}
			/*当p没有右孩子，p的祖先是下个结点的左孩子*/
			else {
				while (p->parent) {
					if (p->parent->lchild == p) break;
					p = p->parent;
				}
				p = p->parent;
			}
			return _iterator(m, pre);
		}
		_iterator &operator--() {
			/*从根节点找到最右的孩子*/
			if (p == 0) {
				p = m->root;
				if (p) while (p->rchild) p = p->rchild;
			}
			else {
				if (p->lchild) {
					p = p->lchild;
					while (p->rchild) p = p->rchild;
				}
				else {
					while (p->parent) {
						if (p->parent->rchild == p) break;
						p = p->parent;
					}
					p = p->parent;
				}
			}
			return *this;
		}
		bool operator!=(_iterator o) { return p != o.p; }
		bool operator==(_iterator o) { return p == o.p; }
	};
	/*最左的孩子*/
	_iterator begin() {
		_pair *p = root;
		if (p) while (p->lchild) p = p->lchild;
		return _iterator(this, p);
	}
	_iterator end() { return _iterator(this, 0); }
	_pair &insert(const Type_key key, Type_value value, bool rep = 1) {
		if (root == 0) {
			root = new _pair(key, value, 0);
			SIZE++;
			return *root;
		}
		_pair *p = root;
		_pair *parent = 0;
		while (p) {
			parent = p;
			if (key < p->first) {
				p = p->lchild;
			}
			else if (key > p->first) {
				p = p->rchild;
			}
			else {
				if (rep) p->second = value;
				return *p;
			}
		}
		_pair *node = new _pair(key, value, parent);
		if (key < parent->first) parent->lchild = node;
		else parent->rchild = node;
		updateheightabove(parent);
		balance(parent->parent);
		SIZE++;
		return *node;
	}
	void erase(const Type_key key) {
		_pair *p = root;
		while (p) {
			if (key < p->first) p = p->lchild;
			else if (key > p->first) p = p->rchild;
			else {
				remove(p);
				return;
			}
		}
	}
	_pair &search(const Type_key key) {
		_pair *p = root;
		while (p) {
			if (key < p->first) p = p->lchild;
			else if (key > p->first) p = p->rchild;
			else return *p;
		}
		Type_value value = Type_value();
		return insert(key, value);
	}
	Type_value &operator[](Type_key key) { return search(key).second; }
};

存储类的时候记得写无参构造函数。

jjccero
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
map的简单模拟实现
风华绝代
07-02 1327
红黑树的插入和删除 map的简单模拟实现
简单Map实现
游先生的博客
05-07 291
package com.java.test.test; public class TestMap<K,V> { private Object[][] pairs; private int index; public TestMap(int length){ pairs = new Object[length][2]; } pu...
实现简单的Map
渣渣瑞
10-24 246
Map map是有数组+链表实现的，代码如下： public class MyMap { LinkedList[] data;//链表 int size; public MyMap(){ this(10); } public MyMap(int c){ data=new LinkedList[c]; } ...
Map的简单实现
铅化内敛->比你牛逼的人比你更努力
03-02 313
Map接口的实现类：HashMap和TreeMap三个特点：存放键值对，根据键对象找对应的值对象，键不能重复。                                                    如下方法中，对Map的put和get都是使用的数组索引。/** * */ package com.sunlei; /** *@author 作者：sunlei *@version ...
自定义实现Map类
qq_35810838的博客
06-02 292
自定义实现Map类 1 package text; 2 3 public class SxtMap001{ 4 SxtEntry[] arr = new SxtEntry[990]; 5 int size; 6 public void put(Object key,Object value){ 7 ...
c++实现的简易map
04-06
在这个特定的项目中，标题提到“c++实现的简易map”，这意味着开发者自己动手实现了一个类似标准库`<map>`的数据结构。描述中指出，这个简易`Map`是在Visual Studio 2019环境下编写的，这通常意味着它是用C++17或更...
Map (c++实现的简易map)
03-16
在C++标准库中，`Map`被实现为`std::map`，但在这个场景中，我们讨论的是一个用户自定义的简易`Map`实现，名为"MyMap"，这是在Visual Studio 2013环境下编写的。 自定义`Map`的主要目的是为了学习和理解数据结构的...
Map实现类1
08-03
Map接口定义了多种操作键值对的方法，而HashMap和TreeMap是两种常见的Map实现类。 1. HashMap - 数据结构：HashMap基于哈希表实现，内部使用数组加链表或者红黑树的结构。每个元素是一个内部类Node，实现了Map....
List转换成Map工具类的简单实例
08-31
本文将详细介绍一个将List转换为Map的工具类实例，它使用了JavaBeans和反射机制来实现这一功能。 首先，我们定义一个名为`List2MapUtils`的工具类，该类包含一个静态方法`convert2Map`。这个方法接受三个参数：`...
js遍历map javaScript遍历map的简单实现
10-21
标题中提到的“js遍历map javaScript遍历map的简单实现”指的是如何在JavaScript中简单实现对Map对象的遍历。在JavaScript中，Map对象是一种存储键值对的结构，类似于Object，但是主要区别在于Map允许任何类型的值...
ASP实现类似hashMap功能的类
10-23
主要介绍了ASP实现类似hashMap功能的类
asp hashmap,arraylist实现
05-29
NULL 博文链接：https://mengdejun.iteye.com/blog/932060
Map实现类
柚咖小窝
12-30 343
HashMap 构造方法 public HashMap() 构造一个空的 HashMap ，具有指定的初始容量和默认负载因子(0.75) public HashMap(Map<? extends K,? extends V> m) 创建一个新的与指定的Map有相同映射的HashMap 。 public HashMap(int initialCapacity) 创建一个初始容量为initialCapacity，默认负载因子(0.75)的HashMap public HashMap(int ini
HashMap简单实现
Elv1s的笔记
05-17 184
手写一个最简单的HashMapMyMap接口MyHashMap测试 MyHashMapTest 写的是数组加链表的HashMap(没有加入红黑树) MyMap接口 package com.tsu.zqy.HashMap; /** * @InterfaceName MyMap * @Author Elv1s * @Date 2019/5/17 16:22 * @Description:...
手动HashMap的简单实现
蜜蜂采蜜
07-22 1846
说起HashMap的强大之处，就是其内部使用了哈希算法和链表算法，充分利用好加载因子的强大推动，使得在时间和空间上的成本寻求一种折中，其内部元素在存储和提取不仅可以充分利用好HashMap初始化的空间，而且查询效率及其的高！ 在面试中，面试官会常问HashMap的底层源码的实现，接下来我简单的手动实现一个HashMap集合： （一）HashMap中存储的元素类型即为键值对存在，定义一个能包含键
map之类数据集合的几个代码小例子
拙言的专栏
06-25 1517
Map之类的一些KV存储数据集合之类，在业务中使用蛮广泛的，其中，在CodeReview中发现，希望用map存储数据，但又能有序取出数据，以及并发安全的map 的需求出现的比较多，而各自的代码实现都有点绕，其实有更好的封装，大家直接拿过来用就好了。 给几个例子: 几个集合的小例子
C++ map简单demo(二十七)
Android系统攻城狮
01-29 953
【代码】C++ map简单demo(二十七)
简单实现C++ hashmap(包含iterator)
choudan8888的博客
08-13 978
原理：原理很简单就是数组和链表，数组是用来散列的，链表主要用来存储的，链表的长度超过8个就转为红黑树（没实现）。 直接上代码： #include<iostream> #include<string> #include<unordered_map> using namespace std; #define LOADFACTOR 0.75 #define EXPANDFACTOR 2 template<class Key, class Value>
ASP实现HashMap
xuchaofu的专栏
03-18 1063
--------------------------------------------------------------ASP版HashMap实现该实现存储数据为有序数据,类似Java中的LinkedHashMap--------------------------------------------------------------Class HashMap dim arr() d
map c++ 简单实现
最新发布
04-29
下面是一个简单实现map的例子，包括了定义、插入、遍历等操作： #include #include <map> using namespace std; int main() { //定义一个map map, string> myMap; //在map中插入元素 myMap.insert(pair, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值