二叉树的C++实现（前中后序和层次遍历，添加删除前中后序线索，中序线索下的一些操作，重构二叉树）

最新推荐文章于 2021-12-17 00:06:46 发布
最新推荐文章于 2021-12-17 00:06:46 发布
阅读量526 收藏
点赞数
分类专栏： 数据结构的C++实现 文章标签： c++ 数据结构 遍历 二叉树 源代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wpy_94/article/details/44571269
版权

一、二叉树的特点：

1. 每个节点都有唯一的父节点；

2. 每个节点最多只有两个子节点，分别为左孩子和右孩子；


二、链式的建立：

1. 根据特点有：


图 2-1 二叉树节点

2. 定义节点类：

template<typename Type>
class BinTreeNode

{

private:
Type data;
BinTreeNode<Type> *leftchild;
BinTreeNode<Type> *rightchild;
FLAG_TYPE ltag;
FLAG_TYPE rtag;
};

3.定义二叉树类：

template<typename Type>
class BinTree
{

private:
BinTreeNode<Type> *root;
Type StopFlag;

};

三、二叉树的线索化：

添加相应的成员，将节点修改为可以添加线索的类型

typedef enum{LINK, THREAD }FLAG_TYPE;
template<typename Type>
class BinTreeNode
{
friend class BinTree<Type>;
public:
BinTreeNode() :data(Type()), leftchild(NULL), rightchild(NULL), ltag(LINK), rtag(LINK)
{}
BinTreeNode(Type d, BinTreeNode<Type> *l = NULL, BinTreeNode<Type> *r = NULL):
data(d), leftchild(l), rightchild(r), ltag(LINK), rtag(LINK)
{}
~BinTreeNode()
{}
private:
Type data;
BinTreeNode<Type> *leftchild;
BinTreeNode<Type> *rightchild;
FLAG_TYPE ltag;
FLAG_TYPE rtag;
};

四、完整源代码：

BinTree.h

#ifndef _BINTREE_H
#define _BINTREE_H

#include<iostream>
#include<string>
using namespace std;

template<typename Type>
class Queue	//实现用于层次遍历需要的功能，也可以#include<queue>
{	//以前有写C语言语法的线性结构，和C++一起用感觉怪怪的所以写了个够用的
public:
	Queue(int sz = 50) :m_ncurrentsize(0), m_nmaxsize(sz)
	{
		if (sz > 0)
		{
			m_data = new Type[m_nmaxsize];
		}
	}
	~Queue()
	{
		delete[]m_data;
	}
public:
	void Push(Type x)
	{
		m_ncurrentsize++;
		for (int j = m_ncurrentsize; j > 0; --j)
		{
			m_data[j] = m_data[j - 1];
		}
		m_data[0] = x;
	}
	void Pop()
	{
		m_ncurrentsize--;
	}
	Type Get()
	{
		return m_data[m_ncurrentsize - 1];
	}
	bool IsEmpty()
	{
		return m_ncurrentsize == 0;
	}
private:
	Type *m_data;
	const int m_nmaxsize;
	int m_ncurrentsize;
};

template<typename Type>
class BinTree;

//typedef一个枚举类型，表示线索的形式
typedef enum{LINK, THREAD }FLAG_TYPE;
template<typename Type>
class BinTreeNode
{
	friend class BinTree<Type>;
public:
	BinTreeNode() :data(Type()), leftchild(NULL), rightchild(NULL), ltag(LINK), rtag(LINK)
	{}
	BinTreeNode(Type d, BinTreeNode<Type> *l = NULL, BinTreeNode<Type> *r = NULL):
		data(d), leftchild(l), rightchild(r), ltag(LINK), rtag(LINK)
	{}
	~BinTreeNode()
	{}
private:
	Type data;
	BinTreeNode<Type> *leftchild;
	BinTreeNode<Type> *rightchild;
	FLAG_TYPE ltag;
	FLAG_TYPE rtag;
};

typedef enum{ NOTH, PRIO, MID, POST }THREAD_TYPE;
template<typename Type>
class BinTree
{
public:
	BinTree() :root(NULL)		
	{}
	BinTree(Type ref) :StopFlag(ref)
	{}
	BinTree(BinTree<Type> &t)//构造结果为无线索二叉树
	{
		root = Copy(t.root);
		StopFlag = t.StopFlag;
	}
	BinTree& operator=(BinTree<Type> &t)//赋值结果为无线索二叉树
	{
		if (this == &t)
			return *this;
		Destory(root);
		root = Copy(t.root);
		StopFlag = t.StopFlag;
		return *this;
	}
	~BinTree()
	{
		Destory(root);
	}
public:
	int Depth()const
	{
		return Depth(root);
	}
	void CreateBinTree()
	{
		Destory(root);
		CreateBinTree(root);
	}
	void CreateBinTree(const char *str)
	{
		Destory(root);
		CreateBinTree(root,str);
	}
	//尽量使用好的函数名代替注释
	void CreateBy_VLR_LVR(const char*svlr,const char *slvr, int n)
	{
		Destory(root);
		CreateBy_VLR_LVR(root, svlr, slvr, n);
	}
	void CreateBy_LVR_LRV(const char*slvr, const char *slrv, int n)
	{
		Destory(root);
		CreateBy_LVR_LRV(root, slvr, slrv, n);
	}
	void CreateInPrioThread()
	{
		BinTreeNode<Type> *pre = NULL;
		CreateInPrioThread(root, pre);
		ttype = PRIO;
	}
	void CreateInMidThread()
	{
		BinTreeNode<Type> *pre = NULL;
		CreateInMidThread(root, pre);
		pre->rtag = THREAD;
		pre->rightchild = NULL;
		ttype = MID;
	}
	void CreateInPostThread()
	{
		BinTreeNode<Type> *pre = NULL;
		CreateInPostThread(root, pre);
		pre->ltag = THREAD;
		pre->leftchild = NULL;
		ttype = POST;
	}
	void ClearThread()
	{
		ClearThread(root);
		ttype = NOTH;
	}
	void PreOrder()const
	{
		PreOrder(root);
	}
	void InOrder()const
	{
		InOrder(root);
	}
	void PostOrder()const
	{
		PostOrder(root);
	}
	void LevelOrder()const
	{
		LevelOrder(root);
	}
	BinTreeNode<Type> *FirstAsInMidThread()const
	{
		return FirstAsInMidThread(root);
	}
	BinTreeNode<Type> *LastAsInMidThread()const
	{
		return LastAsInMidThread(root);
	}
	BinTreeNode<Type> *ParentAsInMidThread(BinTreeNode<Type> *cur)const
	{
		return ParentAsInMidThread(root, cur);
	}
	BinTreeNode<Type> *ParentAsInMidThread(Type x)const
	{
		return ParentAsInMidThread(root, FindAsInMidThread(x));
	}
	BinTreeNode<Type> *FindAsInMidThread(Type x)const
	{
		return FindAsInMidThread(root, x);
	}
	BinTreeNode<Type> *prioAsInMidThread(BinTreeNode<Type> *cur)const;
	BinTreeNode<Type> *NextAsInMidThread(BinTreeNode<Type> *cur)const;

private:
	//如果要求下一个函数参数与上一个函数的调用有关，加指针的引用真实太有必要了
	void CreateBinTree(BinTreeNode<Type> *&t, const char *&str);
	void CreateBinTree(BinTreeNode<Type> *&t);
	void CreateBy_VLR_LVR(BinTreeNode<Type> *&t, const char* svlr, const char* slvr, int n);
	void CreateBy_LVR_LRV(BinTreeNode<Type> *&t, const char* slvr, const char* slrv, int n);
	int Depth(BinTreeNode<Type> *t)const;
	void PreOrder(BinTreeNode<Type> *t)const;
	void InOrder(BinTreeNode<Type> *t)const;
	void PostOrder(BinTreeNode<Type> *t)const;
	void LevelOrder(BinTreeNode<Type> *t)const;
	void Destory(BinTreeNode<Type> *t);
	BinTreeNode<Type> * Copy(BinTreeNode<Type> *t);
	void CreateInPrioThread(BinTreeNode<Type> *cur, BinTreeNode<Type> *&pre);
	void CreateInMidThread(BinTreeNode<Type> *cur, BinTreeNode<Type> *&pre);
	void CreateInPostThread(BinTreeNode<Type> *cur, BinTreeNode<Type> *&pre);
	void ClearThread(BinTreeNode<Type> *t);
	BinTreeNode<Type> *FirstAsInMidThread(BinTreeNode<Type> *t)const;
	BinTreeNode<Type> *LastAsInMidThread(BinTreeNode<Type> *t)const;
	BinTreeNode<Type> *FindAsInMidThread(BinTreeNode<Type> *t, Type &x)const;
	BinTreeNode<Type> *ParentAsInMidThread(BinTreeNode<Type> *root, BinTreeNode<Type> *t)const;
private:
	BinTreeNode<Type> *root;
	Type StopFlag;
	THREAD_TYPE ttype;
};

template <typename Type>
void  BinTree<Type>::ClearThread(BinTreeNode<Type> *t)
{
	if (t != NULL)
	{
		if (t->ltag != THREAD)
			ClearThread(t->leftchild);
		else
		{
			t->ltag = LINK;
			t->leftchild = NULL;
		}
		if (t->rtag != THREAD)
			ClearThread(t->rightchild);
		else
		{
			t->rtag = LINK;
			t->rightchild = NULL;
		}
	}
}

template <typename Type>
BinTreeNode<Type> * BinTree<Type>::ParentAsInMidThread(BinTreeNode<Type> *root, BinTreeNode<Type> *t)const
{
	if (root == NULL || t == NULL || t == root)
		return NULL;
	BinTreeNode<Type> *p = t;
	for (; p->ltag != THREAD;)
		p = p->leftchild;
	p = p->leftchild;
	if ((p != NULL)&&(p->leftchild == t || p->rightchild == t))
			return p;
	p = t;
	for (; p->rtag != THREAD;)
		p = p->rightchild;
	return p->rightchild;
}


template <typename Type>
BinTreeNode<Type> * BinTree<Type>::FindAsInMidThread(BinTreeNode<Type> *t, Type &x)const
{
	if (t == NULL)
		return NULL;
	BinTreeNode<Type> *p = NULL;
	if (t->data == x)
		return t;
	else
	{
		if (t->ltag != THREAD)
			p = FindAsInMidThread(t->leftchild,x);
		if (p == NULL && t->rtag != THREAD)
			p = FindAsInMidThread(t->rightchild,x);
		return p;
	}
}

template <typename Type>
BinTreeNode<Type> * BinTree<Type>::NextAsInMidThread(BinTreeNode<Type> *cur)const
{
	if (cur == NULL)
		return NULL;
	if (cur->rtag == THREAD)
		return cur->rightchild;
	else
		return FirstAsInMidThread(cur->rightchild);
}

template <typename Type>
BinTreeNode<Type> * BinTree<Type>::FirstAsInMidThread(BinTreeNode<Type> *t)const
{
	if (t == NULL)
		return NULL;
	//中序线索第一个元素必为左子树的最左子节点
	while (t->ltag != THREAD)
	{
		t = t->leftchild;
	}
	return t;
}

template <typename Type>
BinTreeNode<Type> * BinTree<Type>::LastAsInMidThread(BinTreeNode<Type> *t)const
{
	if (t == NULL)
		return NULL;
	//中序线索最后一个元素必为右子树的最右子节点
	while (t->rtag != THREAD)
	{
		t = t->rightchild;
	}
	return t;
}

template <typename Type>
BinTreeNode<Type> *BinTree<Type>::prioAsInMidThread(BinTreeNode<Type> *cur)const
{
	if (cur == NULL)
		return NULL;
	if (cur->ltag == THREAD)
		return cur->leftchild;
	else
		return LastAsInMidThread(cur->leftchild);
}

template <typename Type>
void BinTree<Type>::CreateInPrioThread(BinTreeNode<Type> *cur, BinTreeNode<Type> *&pre)
{
	if (cur == NULL)
		return;

	if (cur->leftchild == NULL)
	{
		cur->ltag = THREAD;
		cur->leftchild = pre;
	}
		
	if (pre!= NULL && pre->rightchild == NULL)
	{
		pre->rtag = THREAD;
		pre->rightchild = cur;
	}

	pre = cur;
	if (cur->ltag == LINK)
		CreateInPrioThread(cur->leftchild, pre);

	if (cur->rtag == LINK)
		CreateInPrioThread(cur->rightchild, pre);

}

template <typename Type>
void BinTree<Type>::CreateInPostThread(BinTreeNode<Type> *cur, BinTreeNode<Type> *&pre)
{
	if (cur == NULL)
		return;
	CreateInPostThread(cur->rightchild, pre);//初始方向为右
	if (cur->rightchild == NULL)
	{
		cur->rtag = THREAD;
		cur-> rightchild= pre;
	}
	if (pre != NULL && pre-> leftchild== NULL)
	{
		pre->ltag = THREAD;
		pre->leftchild = cur;
	}
	pre = cur;
	CreateInPostThread(cur->leftchild, pre);
}

template <typename Type>
void BinTree<Type>::CreateInMidThread(BinTreeNode<Type> *cur, BinTreeNode<Type> *&pre)
{
	if (cur == NULL)
		return;
	CreateInMidThread(cur->leftchild, pre);//初始方向为左
	if (cur->leftchild == NULL)	
	{
		cur->ltag = THREAD;
		cur->leftchild = pre;
	}
	if (pre != NULL && pre->rightchild == NULL)
	{
		pre->rtag = THREAD;
		pre->rightchild = cur;
	}
	pre = cur;
	CreateInMidThread(cur->rightchild, pre);
}

template <typename Type>
void BinTree<Type>::CreateBy_LVR_LRV(BinTreeNode<Type> *&t, const char* slvr, const char* slrv, int n)
{
	if (n == 0)
		return;
	int i = 0;
	while (slrv[n - 1] != slvr[i])
	{
		++i;
	}
	//char *lvr = "CBEDF A GH"
	//char *lrv = "CEFDB HG A";
	t = new BinTreeNode<Type>(slvr[i]);
	CreateBy_LVR_LRV(t->rightchild, slvr + i + 1, slrv + i, n - i - 1);
	CreateBy_LVR_LRV(t->leftchild, slvr, slrv, i);
}

template <typename Type>
void BinTree<Type>::CreateBy_VLR_LVR(BinTreeNode<Type> *&t,const char* svlr,const char* slvr,int n)
{
	if (n == 0)
		return;
	int i = 0;
	while (svlr[0] != slvr[i])
	{
		++i;
	}
	//char *vlr = "ABCDEFGH";
	//char *lvr = "CBEDFAGH";
	t = new BinTreeNode<Type>(slvr[i]);
	CreateBy_VLR_LVR(t->leftchild, svlr + 1, slvr, i);
	CreateBy_VLR_LVR(t->rightchild, svlr + i + 1, slvr + i + 1, n - i - 1);
}

template <typename Type>
BinTreeNode<Type> * BinTree<Type>::Copy(BinTreeNode<Type> *t)
{
	if (t == NULL)
		return NULL;
	BinTreeNode<Type> *p = new BinTreeNode<Type>;
	p->data = t->data;
	if (t->ltag != THREAD)
		p->leftchild = Copy(t->leftchild);
	else
		p->leftchild = NULL;
	if (t->rtag != THREAD)
		p->rightchild = Copy(t->rightchild);
	else
		p->rightchild = NULL;
	return p;
}

template <typename Type>
void BinTree<Type>::Destory(BinTreeNode<Type> *t)
{
	if (t == NULL)
		return;
	if (t->ltag != THREAD)
		Destory(t->leftchild);
	if (t->rtag != THREAD)
		Destory(t->rightchild);
	delete t;
}

template <typename Type>
void BinTree<Type>::PreOrder(BinTreeNode<Type> *t)const
{
	if (t != NULL )
	{
		cout << t->data;
		//添加遍历线索后需要添加判断语句来结束递归
		if(t->ltag != THREAD)
			PreOrder(t->leftchild);
		if (t->rtag != THREAD)
			PreOrder(t->rightchild);
	}
}
template <typename Type>
void BinTree<Type>::CreateBinTree(BinTreeNode<Type> *&t, const char *&str)
{
	char ch = str[0];
	str++;
	if (ch == StopFlag)
	{
		t = NULL;
	}
	else
	{
		t = new BinTreeNode<Type>(ch);
		CreateBinTree(t->leftchild, str);
		CreateBinTree(t->rightchild, str);
	}
}

template <typename Type>
void BinTree<Type>::CreateBinTree(BinTreeNode<Type> *&t)
{
	Type item;
	cin >> item;
	if (item == StopFlag)
		t = NULL;
	else
	{
		t = new BinTreeNode<Type>(item);
		CreateBinTree(t->leftchild);
		CreateBinTree(t->rightchild);
	}
}

template <typename Type>
int BinTree<Type>::Depth(BinTreeNode<Type> *t)const
{
	int dleft, dright, max;
	if (t == NULL)
		return 0;
	else
	{
		dleft = Depth(t->leftchild);
		dright = Depth(t->rightchild);
		max = dleft > dright ? dleft : dright;
		return max + 1;
	}
}

template <typename Type>
void  BinTree<Type>::InOrder(BinTreeNode<Type> *t)const
{
	if (t != NULL)
	{
		if (t->ltag != THREAD)
			InOrder(t->leftchild);
		cout << t->data;
		if (t->rtag != THREAD)
			InOrder(t->rightchild);
	}
}

template <typename Type>
void BinTree<Type>::PostOrder(BinTreeNode<Type> *t)const
{
	if (t != NULL)
	{
		if (t->ltag != THREAD)
			PostOrder(t->leftchild);
		if (t->rtag != THREAD)
			PostOrder(t->rightchild);
		cout << t->data;
	}
}

template <typename Type>
void BinTree<Type>::LevelOrder(BinTreeNode<Type> *t)const
{
	Queue<BinTreeNode<Type>*> Que;
	Que.Push(t);
	BinTreeNode<Type>* s = NULL;
	while (!Que.IsEmpty())
	{
		s = Que.Get();
		cout << s->data;
		if (s->leftchild != NULL && s->ltag != THREAD)//要出它，便先入它的孩子
			Que.Push(s->leftchild);
		if (s->rightchild != NULL && s->rtag != THREAD)
			Que.Push(s->rightchild);
		Que.Pop();
	}
}

#endif
Test.cpp 

#include"BinTree.h"

int main(int argc, char *argv[])
{
	char *ch = "ABC##DE##F##G#H##";
	BinTree<char> bin('#');
	bin.CreateBinTree(ch);
	bin.PreOrder();
	cout << endl;
	bin.InOrder();
	cout << endl;
	bin.PostOrder();
	cout << endl;
	bin.LevelOrder();
	cout << endl;
	cout << bin.Depth() << endl;
	//为bin添加中序线索
	bin.CreateInMidThread();
	//在中序中做一些查找操作
	BinTreeNode<char> *p1 = bin.FirstAsInMidThread();
	BinTreeNode<char> *p2 = bin.NextAsInMidThread(p1);
	BinTreeNode<char> *q1 = bin.LastAsInMidThread();
	BinTreeNode<char> *q2 = bin.prioAsInMidThread(q1);
	BinTreeNode<char> *pp = bin.FindAsInMidThread('H');
	BinTreeNode<char> *ppp = bin.ParentAsInMidThread(pp);
	BinTreeNode<char> *pppp = bin.ParentAsInMidThread('H');
	//修改后的遍历函数可以适应各种情况
	bin.PreOrder();
	cout << endl;
	bin.InOrder();
	cout << endl;
	bin.PostOrder();
	cout << endl;
	bin.LevelOrder();
	cout << endl;
	bin.ClearThread();

	char *vlr = "ABCDEFGH";
	char *lvr = "CBEDFAGH";
	char *lrv = "CEFDBHGA";
	BinTree<char> bin2('#');
	bin2.CreateBy_VLR_LVR(vlr, lvr, strlen(lvr));
	bin2.CreateInPrioThread();

	BinTree<char> bin3(bin2);
	bin3.CreateBy_LVR_LRV(lvr, lrv, strlen(lvr));
	bin3.CreateInPostThread();

	system("pause");
	return 0;
}
五、运行及测试结果：

图 5-1 添加中序线索的树示例

图 5-2 测试程序运行结果



wpy_94
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树先中后序遍历的C++代码
qq_38946392的博客
12-26 3299
马上就要数据结构考试了，会考到二叉树的遍历算法设计题，然后就自己总结了一个关于二叉树的简单算法代码。 #include #include #include #include #define MAX 100 using namespace std; //二叉树的储存结构 typedef struct bit { char data; struct bit *lchild
二叉树的建立及前中后序遍历
Write Code Change Life
11-27 462
#include #include #include using namespace std; typedef struct BiNode { char data; struct BiNode *lch; struct BiNode *rch; }BiNode,*BiTree; void creat(BiTree &T) { T=(BiNode*)mallo
二叉树c++源代码实现查找，删除，插入等
11-09
二叉树c++源代码实现查找，删除，插入等二叉树必须的操作。调试通过，函数中注释掉的为各模块的试验例子
C语言实现二叉树的创建、插入、删除、遍历等操作
12-14
C语言实现二叉树的创建、插入、删除、遍历（先序、中序、后续、深度优先、广度优先）、计算度为0,1,2的节点个数。 包括排序二叉树的实现
二叉查找树原理分析及查找、插入、删除、遍历实现
code4grow专栏
04-08 2572
二叉查找树作为一种最简单的二叉排序树，它是特殊的二叉树：对于二叉树，假设x为二叉树中的任意一个结点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个结点，则key[y] >= key[x]。那么，这棵树就是二叉查找树。 二叉查找树具有如下性质：1、如果节点左子树存在，那么左子树中的所有值均小于其根节点的值2、如果节点右子树
cd.zip_THU OJ_oj_reconfiguration_thu dsa_重构 二叉树
09-23
“二叉树重构”是本问题的核心，它可能指的是给定一个二叉树的某种表示（例如，前序遍历、中序遍历或后序遍历的序列），要求根据这个序列重建原来的二叉树。这需要对二叉树的遍历方式有深入的理解。前序遍历顺序为：...
支持可重构计算的满二叉树中序存储策略及快速遍历算法 (2011年)
05-14
通过对满二叉树顺序存储序列与中序序列之间解析关系的研究，推导与证明了完全二叉树的一些重要性质，给出了一种可快速访问的满二支树中序序列存储方法并设计出相应的遍历算法。基于该方法，一颗具有N个结点的满...
二叉树的常用算法的实现
01-27
在`BinaryTree-master`这个项目中，可能会包含各种二叉树算法的实现，包括但不限于上述的插入、删除、遍历和重构。通过阅读和学习这些代码，你可以加深对二叉树及其操作的理解，并提升C++编程能力。记得实践是检验...
用C++实现二叉树的各种操作
07-01
3. 给定二叉树的先序和中序遍历结果，如何重构二叉树。 ### 1. 利用先序遍历和层次遍历的结果建立二叉树 在C++中，我们可以定义一个`BinTreeNode`类来表示二叉树中的每个节点，并且定义一个`BinaryTree`类来封装...
构建，重构二叉树并输出
11-06
在IT领域，特别是数据结构和算法的学习中，构建和重构二叉树是一项基本技能。本文将深入探讨如何根据前序序列和中序序列构建二叉树，并使用MFC（Microsoft Foundation Classes）框架来实现图形化输出。对于二叉树的...
线索二叉树的建立、删除、插入、恢复线索
06-29
线索二叉树的建立 删除 插入 恢复线索
线索二叉树的建立与实现
05-13
在查找比较经常的二叉树中，如果用普通的二叉树则会耗费较多的时间，为止我们考虑使用二叉树来提高效率。
线索二叉树的插入，删除
05-26
一、内容 线索二叉树的应用。实现线索二叉树的建立、插入、删除、恢复线索的实现。
二叉排序树的建立、插入、删除、查找、4种遍历 C++完整实现
Duplan的专栏
04-01 7210
#include #include #include using namespace std; typedef int KeyType; #define NUM 13 class BinSTree; class BinStreeNode { public: KeyType key; BinStreeNode *lchild; BinStreeNode *rchild; BinStreeN
C++ 二叉树 前序遍历 中序遍历 后序遍历
weixin_40702444的博客
12-17 9434
C++ 二叉树 前序遍历 中序遍历 后序遍历 通过递归代码推出非递归实现 通过遍历规则推出非递归实现
c语言实现二叉树先序，中序，后序（递归），层次遍历，求叶子节点个数及树的深度，下一篇写非递归的遍历
u014574317的博客
04-04 1万+
#include #include #define MAXSIZE 30 typedef char ElemType; typedef struct TNode *BiTree; struct TNode { char data; BiTree lchild; BiTree rchild; }; int IsEmpty_BiTree(BiTree *T) { if(*T
C++实现二叉树的插入、删除、查询、遍历
热门推荐
远走的兔子博客
04-09 4万+
1.二叉树的概念        树是一些节点的集合，节点之间用边链接，节点之间不能有环路。上层的节点称为父节点，下层节点称为子节点。最上层的节点称为根节点。       二叉树是特殊的树。对于每个节点而言，与之直接相连的子节点不能超过两个（可以为0）。左边的子节点称为左子树，右边的子节点称为右子树。如下图就是一颗二叉树： 与树相关的一些概念：          没有任何子节点的节点
二叉树遍历、插入、删除等常见操作
Sunshine的专栏
12-03 1万+
1.二叉查找树的创建 2.二叉查找树清空 3.二叉查找树查询 4.查找最大值、最小值 5.二叉查找树插入操作 6.二叉查找树的删除操作 7.分别使用非递归和递归方式（部分用多种方式）实现树的先序遍历、中序遍历和后序遍历
C++实现二叉树的先序、中序、后序遍历,包括递归方式和非递归 方式
暮日落流年的博客
07-05 1万+
C++实现二叉树的先序、中序、后序遍历,包括递归方式和非递归方式。 1. 二叉树的基本结构 struct Node { int value; Node* left; Node* right; Node(int value): value(value), left(nullptr), right(nullptr) {} }; 2. 递归和非递归方...
现有两个结点序列，分别是对同一个二叉树进行前序遍历和中序遍历（或中序和后序）的结果。要求设计一个算法，重构该二叉树，并输出该二叉树按照后序（前序）遍历时的结点序列。假定二叉树所有的结点的数据域的值都不相同。使用c++解决。
最新发布
06-01
然后，我们可以在中序遍历序列中找到该根节点的位置，以此将整个二叉树划分为左子树和右子树，并且递归处理左右子树。 对于左子树，我们可以利用前序遍历序列和左子树的中序遍历序列递归构建左子树。对于右子树，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值