自写STL二叉树容器

最新推荐文章于 2024-10-10 17:40:47 发布
最新推荐文章于 2024-10-10 17:40:47 发布
阅读量426 收藏
点赞数
分类专栏： s 文章标签： c++ 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37381642/article/details/107730188
版权

最近看完了侯捷的STL源码剖析，自己写个案例练练手
这是一个二叉树的容器,参照stl容器
主要实现以下功能：
1.构造函数：可通过两种方式构造
(1)空构造;(2)设置原生指针或容器的头尾指针/迭代器将其填充，第三个参数为空位符，在树中表示NULL；
2.插入函数：
提供左插入insert_left与右插入insert_right，当对应位置已有节点时将该点作为插入点的子节点，第三个参数设置该子节点为其左子/右子，默认为左子，设0则为右子；
3.擦除函数：
提供节点删除erase与枝删除erasebranch，其中节点删除仅适用于子节点<=1的情况,删除节点后由子节点接替其位置。
枝删除通过后序遍历依次将节点释放。
4.遍历方式：
提供4种遍历模式：①层序遍历levelOrder②前序遍历preorderTraversal③中序遍历inorderTraversal④后序遍历postorderTraversal
第一个参数为遍历的起始节点，第二个为仿函数接口，即遍历过程中要完成的动作。其中层序遍历的仿函数需两个参数，第一个相邻层间过渡的标志，过渡时为1。另一个参数为节点的数值。
5.查找函数find：
第一个参数为需查找的数值，第二个参数为起始节点。返回其迭代器。
6.旋转函数：
提供左旋rotate_left与右旋函数rotate_right，即平衡二叉树中常用的旋转操作。
7.迭代器iterator：
通过迭代器来访问二叉树的节点，可实现节点的移动与访问
(1)移动：++往下，–往上，可通过iter_left，iter_right，选择向下的方向（往左/往右）。
(2)访问：重载与->，可通过访问节点数值，->可访问节点成员变量。

上述功能均通过了简单的测试，但时间有限，还没在实际案例中应用，后续根据需要继续完善功能

代码如下：

//踏梦远行——2020.8.1
#include<iostream>
#include<vector>
#include<queue>
#include<list>
#include<sstream>
using namespace std;

template<class T>
struct treenode
{
	typedef treenode<T>* pointer;
	T data;
	pointer left;
	pointer right;
	pointer parent;
};

//-------------------------

template<class T>
class treeiter
{
public:
	typedef treenode<T>* pointer;
	treeiter() :itertype(0) {};
	treeiter(pointer n) :node(n),itertype(0) {};
	void operator=(pointer n) { node = n; itertype = 0; };
	pointer operator++(int);
	pointer& operator++();
	pointer operator--(int);
	pointer& operator--();
	bool operator==(pointer p)const {return this->node == p;};
	T operator *()const { return node->data; };
	typename treeiter<T>::pointer operator ->() { return node; };
	void iter_left() { itertype = 0; };
	void iter_right() { itertype = 1; };
	pointer node;
private:
	unsigned char itertype;
};

template<class T>
typename treeiter<T>::pointer treeiter<T>::operator++(int)
{
	pointer tmp = node;
	switch (itertype) {
	case 0:node = node->left;
		break;
	case 1:node = node->right;
		break;
	default:
		break;
	}
	return tmp;
}

template<class T>
typename treeiter<T>::pointer& treeiter<T>::operator++()
{
	switch (itertype) {
	case 0:node = node->left;
		break;
	case 1:node = node->right;
		break;
	default:
		break;
	}
	return node;
}

template<class T>
typename treeiter<T>::pointer treeiter<T>::operator--(int)
{
	pointer tmp = node;
	node = node->parent;
	return tmp;
}

template<class T>
typename treeiter<T>::pointer& treeiter<T>::operator--()
{
	node = node->parent;
	return node;
}


//-------------------------

template<class T>
class mytree
{
public:
	typedef treenode<T> value;
	typedef treenode<T>* pointer;
	typedef treeiter<T> iterator;
	mytree();
	template<class U>
	mytree(U l, U r, T sign);
	iterator gethead() { return head; }
	iterator begin() { return head->left; }
	iterator end() { return NULL; }
	void insert_left(treeiter<T> parent, T x, bool left = 1);
	void insert_right(treeiter<T> parent, T x, bool left = 1);
	void erase(treeiter<T> parent);
	void erasebranch(treeiter<T> parent);
	template<class func>
	void levelOrder(iterator pos, func& fun);
	template<class func>
	void preorderTraversal(iterator pos,func& fun);
	template<class func>
	void inorderTraversal(iterator pos, func& fun);
	template<class func>
	void postorderTraversal(iterator pos, func& fun);
	iterator find(T pos, iterator start);
	void rotate_left(iterator start);
	void rotate_right(iterator start);
private:
	pointer head;
	pointer node;
	template<class U>
	void constuctree(U l, U r, T sign, random_access_iterator_tag);
	template<class U>
	void constuctree(U l, U r, T sign, input_iterator_tag);
	pointer createnode() { return new value; }
	void erasebranch_base(iterator parent);
};

template<class T>
mytree<T>::mytree() {
	head = new value;
	head->left = NULL;
	head->right = NULL;
	head->parent = NULL;
	node = head;
};

template<class T>
template<class U>
mytree<T>::mytree(U l, U r,T sign) {
	constuctree( l, r,sign,iterator_traits<U>::iterator_category());
};

template<class T>
template<class U>
void mytree<T>::constuctree(U l, U r, T sign,random_access_iterator_tag)
{
	head = new value;
	head->left = NULL;
	head->right = NULL;
	head->parent = NULL;
	node = head;
	if (l <= r)
	{
		U pos = l;
		treeiter<T> it = head;
		int n = r - l - 1;
		insert_left(it, *pos++);
		queue<pointer> myq;
		myq.push(begin());
		while (n > 0)
		{
			it = myq.front();
			myq.pop();
			if (*pos!=sign) {
				insert_left(it, *pos);
				myq.push(it->left);
			}
			pos++;
			if (!--n)break;
			if (*pos!=sign) {
				insert_right(it, *pos);
				myq.push(it->right);
			}
			pos++;
			--n;
		}
	}
}

template<class T>
template<class U>
void mytree<T>::constuctree(U l, U r, T sign,input_iterator_tag)
{
	head = new value;
	head->left = NULL;
	head->right = NULL;
	head->parent = NULL;
	node = head;
	U pos = l;
	treeiter<T> it = head;
	insert_left(it, *pos++);
	queue<pointer> myq;
	myq.push(head->left);
	while (pos !=r)
	{
		it = myq.front();
		myq.pop();
		if (*pos!=sign) {
			insert_left(it, *pos);
			myq.push(it->left);
		}
		pos++;
		if (pos==r)break;
		if (*pos!=sign) {
			insert_right(it, *pos);
			myq.push(it->right);
		}
		pos++;
	}
}

template<class T>
void mytree<T>::insert_left(treeiter<T> parent, T x, bool left)
{
	node = createnode();
	node->parent = parent.node;
	node->data = x;
	if (left)node->left = parent.node->left;
	else node->right = parent.node->left;
	node->right = NULL;
	parent.node->left = node;
}

template<class T>
void mytree<T>::insert_right(treeiter<T> parent, T x, bool left) {
	node = createnode();
	node->parent = parent.node;
	node->data = x;
	if (left)node->left = parent.node->right;
	else node->right = parent.node->right;
	node->right = NULL;
	parent.node->right = node;
}

template<class T>
void mytree<T>::erase(treeiter<T> parent)
{
	if (!parent->left && !parent->right) {
		if (parent == parent->parent->left)parent->parent->left = NULL;
		else parent->parent->right = NULL;
		delete parent.node;
		return;
	}
	if (!parent->left){
		if (parent->parent->left == parent.node) parent->parent->left = parent->right;
		else parent->parent->right = parent->right;
		parent->right->parent = parent->parent;
		delete parent.node;
		return;
	}
	if (!parent->right) {
		if (parent->parent->left == parent.node) parent->parent->left = parent->left;
		else parent->parent->right = parent->left;
		parent->left->parent = parent->parent;
		delete parent.node;
		return;
	}
}

template<class T>
void mytree<T>::erasebranch(iterator parent)
{
	if (parent == parent->parent->left)parent->parent->left = NULL;
	else parent->parent->right = NULL;
	erasebranch_base(parent);
}

template<class T>
void mytree<T>::erasebranch_base(iterator parent)
{
	if (!parent.node) return;
	erasebranch_base(parent->left);   //后序遍历
	erasebranch_base(parent->right);
	delete parent.node;
}



template<class T>
template<class func>
void mytree<T>::levelOrder(mytree<T>::iterator pos,func& fun) {
	if (!pos.node)return;
	pointer temp;
	queue<pointer> myq;
	myq.push(pos.node);
	int len;
	while (!myq.empty())
	{
		len = myq.size();
		for (int i = 0; i < len; i++)
		{
			temp = myq.front();
			myq.pop();
			fun(!i,temp->data);
			if (temp->left)myq.push(temp->left);
			if (temp->right)myq.push(temp->right);
		}
	}
}

template<class T>
template<class func>
void mytree<T>::preorderTraversal(mytree<T>::iterator pos,func& fun) {
	if (!pos.node) return;
	fun(pos->data);
	preorderTraversal(pos->left,fun);
	preorderTraversal(pos->right,fun);
}

template<class T>
template<class func>
void mytree<T>::inorderTraversal(mytree<T>::iterator pos, func& fun) {
	if (!pos.node) return;
	inorderTraversal(pos->left,fun);
	fun(pos->data);
	inorderTraversal(pos->right,fun);
}

template<class T>
template<class func>
void mytree<T>::postorderTraversal(mytree<T>::iterator pos, func& fun) {
	if (!pos.node) return;
	postorderTraversal(pos->left, fun);
	postorderTraversal(pos->right, fun);
	fun(pos->data);
}

template<class T>
typename mytree<T>::iterator mytree<T>::find(T pos, mytree<T>::iterator start)
{
	if (!start.node)return NULL;
	if (start->data == pos)return start;
	if (find(pos, start->left).node)return find(pos, iterator(start->left));
	if (find(pos, start->right).node)return find(pos, iterator(start->right));
	return NULL;
}

template<class T>
void mytree<T>::rotate_left(mytree<T>::iterator start)
{
	if (!start->right)return;
	if (start == start->parent->right)start->parent->right = start->right;
	else  start->parent->left = start->right;
	start->right->parent = start->parent;
	start->parent = start->right;
	start->right = start->parent->left;
	start->parent->left = start.node;
	if(start->right)start->right->parent = start.node;
	start = start->parent;
}

template<class T>
void mytree<T>::rotate_right(mytree<T>::iterator start)
{
	if (!start->left)return;
	if (start == start->parent->right)start->parent->right = start->left;
	else  start->parent->left = start->left;
	start->left->parent = start->parent;
	start->parent = start->left;
	start->left = start->parent->right;
	start->parent->right = start.node;
	if (start->left)start->left->parent = start.node;
	start = start->parent;
}


//-------------------------

template<class T>
void show(vector<vector<T>> v)
{
	for (int i = 0; i < v.size(); i++)
	{
		for (int j = 0; j < v[i].size()-1; j++)
			cout << v[i][j]<<"| |";
		cout << v[i][v[i].size()-1]<<endl;
	}
}

template<class T>
void show(vector<T> v)
{
	for (int i = 0; i < v.size()-1; i++)
	{
		cout << v[i] << "| |";
	}
	cout << v[v.size() - 1] << endl;
}

class savevec
{
public:
	vector<double> v;
	void operator()(double x)
	{
		v.push_back(x);
	}
	~savevec() { v.clear(); };
};

class savevvec
{
public:
	vector<vector<double>> v;
	void operator()(int sign,double x)
	{
		if (sign)(v.push_back({}));
		v.back().push_back(x);
	}
	~savevvec() { v.clear(); };
};


int main()
{
	double arr[] = { 1,5,6,8,9,7,3,0,9,10 };
	list<double> l(arr, arr + 10);
	mytree<double> t(l.begin(),l.end(),0);
	//treeiter<double> it = t.gethead();
	//t.insert_left(it, 5);
	//it.iter_left();
	//it++;
	//t.insert_left(it, 4.7);
	//t.insert_right(it, 10.5);
	//t.insert_right(it, 9);
	//it--;
	//t.insert_left(it, 8);
	mytree<double>::iterator it = t.begin();
	savevvec savv;
	t.levelOrder(it,savv);
	show(savv.v);
	cout << "----------" << endl;
	savevec sav;
	t.preorderTraversal(it,sav);
	show(sav.v);
	sav.v.clear();
	t.erase(t.find(8, t.begin()));
	t.inorderTraversal(it,sav);
	show(sav.v);
	sav.v.clear();
	t.erasebranch(t.find(6, t.begin()));
	t.postorderTraversal(it,sav);
	show(sav.v);
	sav.v.clear();
	it=t.find(5, t.begin());
	t.rotate_right(it);
	system("pause");
}
踏梦xox远行
关注
专栏目录
c++之stl 二叉树
.
03-07 3万+
set是根据元素值进行排序的集合，所插入的元素在集合中唯一，不存在重复元素。 set由二叉搜索树实现，并且对树进行了平衡处理，使得元素在树中分部较为均匀，因此能保持搜索、插入、删除的复杂度在O(logn)。 函数名 功能 复杂度 size() 返回set中的元素数 O(1) clear() 清空set O（n） begin（） 返回指
C++中STL各容器详解
king_weng的博客
03-09 7274
一、STL中六大组件： 1）容器（Container），是一种数据结构，如list，vector，和deques ，以模板类的方法提供。为了访问容器中的数据，可以使用由容器类输出的迭代器； 2）迭代器（Iterator），提供了访问容器中对象的方法。例如，可以使用一对迭代器指定list或vector中的一定范围的对象。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器也可以...
数据结构 C++ STL 二叉树
01-21
二叉树 二叉树的递归遍历和非递归遍历 二叉树的迭代器 线索二叉树（中序）
【STL】12 二叉树set容器操作
piano_diano的博客
02-26 336
只能把节点删了再加入新的节点，不能改节点的值 #include<iostream> #include<set> using namespace std; //仿函数 class mycompare{ public: bool operator()(int v1,int v2){ return v1 &g...
【STL】二叉搜索树模拟实现
最新发布
gaogo
10-10 1820
讲解二叉搜索树的特性。模拟实现二叉搜索树的插入、查找、中序遍历和删除（三种情况）
map/multimap容器(二叉树)
m0_64837135的博客
03-26 1191
简介map中所有的元素都是pair(对组)。pair中第一个元素为key(键值)，起到索引作用，第二个元素为value(实值) 所有元素会根据元素的键值来自动排序。 本质底层结构是二叉树。 优点 快速通过key值找到value。 map容器与multimap容器区别？ map容器不允许容器中有重复的key值元素。multimap容器允许容器中有重复的key值。multi(多，多重) #include <iostream> using namespace std; #include &l
set/multiset容器（二叉树）
m0_64837135的博客
03-26 1147
所有的元素都会在插入时自动被排序。 set容器与multiset容器本质在底层结构是二叉树，头文件均为#include <set> set容器与multiset容器有什么区别？ set容器不允许容器中有重复的元素。 multiset容器允许容器有重复的元素。 #include <iostream> using namespace std; #include <set> //set/multiset void printSet(set<int> &
二叉树----set集合容器
Cynical丶Gary_博客
07-30 785
set集合容器实现了红黑树(Red-Black Tree)的平衡二叉搜索树的数据结构，在插入元素时，它会自动调整二叉树的排列，把该元素放到适当的位置，以确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有检点的键值；另外，还得确保根节点左子树的高度与右子树的高度相等，这样，二叉树的高度最小，从而搜索速度最快。 set容器不会插入重复相同键值的元素，而采取忽略处理。下面网上找的一张s
STL- 常用容器
m0_53263647的博客
02-14 966
一、string容器1、string基本概念本质：string是C++风格的字符串，而string本质上是一个类string和char * 区别：char * 是一个指针string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。特点：string 类内部封装了很多成员方法例如：查找find，拷贝copy，删除delete 替换replace，插入insertstring管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责。
【C++】STL各容器对比
paxlhhh
08-21 538
STL对比
实现一个简单的二叉树容器，并且实现中序、先序、后序遍历
weixin_44173944的博客
03-20 271
二叉树定义： 是一种树形结构，他的特点是每个结点最多只有两颗子树（即二叉树中不存在度大于2的结点），并且二叉树的子树有左右之分，其次序不能任意颠倒。 二叉树的性质： 二叉树的第i层上最多有 2^(i-1) 个结点，（i>=1）； 深度为k的二叉树最多有 2^k - 1 个结点，（k >=1）； 对任何一颗二叉树，如果其终端结点数为N0，度为2的节点数为N2，那有N0 = N2 + 1...
C++创建二叉树及操作
04-19
C++创建二叉树及操作包括前序遍历后序遍历层序遍历 深度 叶子节点
C++使用STL实现二叉树 前、中、后序遍历（非递归)
weixin_44161513的博客
06-09 1336
最近刚学到数据结构的二叉树部分,想用C++实现二叉树的前序、中序、后序遍历 一般二叉树的遍历有两种方法，递归和非递归，递归这里就不说了，网上各个版本都差不多，非递归一般是用栈来实现的，这里主要说一下非递归。 先简单说明一下这 3 种遍历方式有什么不同 —— 对于每种遍历，树中每个结点都需要经过 3 次（对于叶结点，其左右子树视为空子树），但前序遍历在第一次遇到结点时就立即访问，中序遍历是在第二次遇到结点时访问，后序遍历则是第三次访问。 所谓的前序、中序、后序都是以根节点为标准，前序就是先遍历根节点，中序就是
【STL】平衡二叉树 || 排序容器 multiset + set
qq_45697327的博客
09-06 739
【STL】平衡二叉树||排序容器（一）multiset + set。概念整理与简单题。
C++通过容器创建二叉树以及遍历（递归/非递归：前、中、后、层）————附带详细代码
韩江雪de 小屋
01-07 1477
文章目录0 背景1 生成二叉树1.1 二叉树的链式存储结构1.2 二叉树的创建2 遍历代码2.1 前序遍历2.1.1 递归2.2 非递归2.2 中序遍历2.2.1 递归2.2.2 非递归2.3 后序遍历2.3.1 递归2.3.2 非递归2.4 层序遍历3 完整的示例代码4 关联二叉查找树的创建 0 背景 在学习二叉树的遍历时，学习了很多遍历的方式，但是想要验证遍历的代码，奈何很多书籍都没有讲如何创建二叉树，网上也查了很多资料都是需要手动输入一个一个的节点通过递归来创建，不能传一个容器过去，通过容器中的元
C++ 纪念一下第一次用STL （重建二叉树）
Seven2xx的博客
03-28 296
C++ 纪念一下第一次用STL写重建二叉树 题目来源：《剑指offer》面试题7：重建二叉树 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。 示例：输入：[1,2,3,4,5,6,7],[3,2,4,1,6,5,7] 输出：{1,2,5,3,4,6,7} /** * Definition for binary tree
自己动手写STL中的vector
晴天的专栏
11-13 1483
M0313-array_class_template.h#ifndef DYNAMIC_ARRAY_H_ #define DYNAMIC_ARRAY_H_ #include #include struct A { A(int n = 0): i(n) { printf("A(%d)\n", i); } ~A() { printf("~A(%d)\n", i); } i
使用STL容器构成一棵树
qilihechuncai的专栏
12-08 637
<br />下面使用vector容器为基础来构成一棵树.<br />例如生成以下结构的树.<br /><br />3<br />2 2 2 2<br />1111 1111 1111 1111<br /><br />这是课四叉数, 而且下层比上层的值小1.<br /><br />来看代码: <br />//使用STL构成一棵树<br /><br />#include<vector> //vector容器<br />#include<iostream> //输入输出<br /><br />usin
Java容器：（七）二叉树和红黑树
地球村
05-08 260
二叉树和红黑树1.树2.二叉树3.二叉查找/搜索/排序树 BST (binary search/sort tree)4.平衡二叉树（Self-balancing binary search tree）自平衡二叉查找树又被称为 AVL树（有别于 AVL 算法）5.红黑树 1.树 树是由一个集合以及在该集合上定义的一种关系构成的。 集合中的元素称为树的结点，所定义的关系称为父子关系。 父子关系在树的...
C++ STL库容器深入解析与应用指南
本资源通过分别对各个STL容器和算法进行详细解析，帮助学习者深入理解和掌握STL的使用方法。 在C++中，STL包括六个主要的组件：容器（Container）、迭代器（Iterator）、算法（Algorithm）、函数对象（Function ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值