顺序二叉树的基础操作（C++）

最新推荐文章于 2022-05-28 15:20:23 发布
原创 最新推荐文章于 2022-05-28 15:20:23 发布 · 735 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#二叉树

本文详细介绍了二叉查找树的基本概念、结构定义及其主要操作，包括递归与非递归的查找、插入、删除等算法，并探讨了二叉树的遍历方式与线索化过程。

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

#ifndef _BSTREE_
#define _BSTREE_

template<typename T>
struct BSNode{
	BSNode(T t) :value(t),lchild(nullptr),rchild(nullptr);

	T value;
	BSNode *lchild;
	BSNode *rchild;
	BSNode *parent;
	int LTag;
	int RTag;//0：指向左右孩子的指针；1：指向前驱/后继的线索
};

//二叉查找树类
/*1.BSTree的根节点root，这是唯一的数据成员
2.操作的外部接口与内部实现接口。例如 preOrder()为提供给用户使用的接口，接口声明为public；而preOrder(AVLTreeNode* pnode)是类内部为了递归操作所使用的接口，接口声明为private。*/
template<typename T>
class BSTree
{
public:
	BSTree();
	~BSTree();

	void preOrder();   //前序遍历二叉树
	void inOrder();        //中序遍历二叉树
	void postOrder();   //后序遍历二叉树
	void layerOrder();    //层次遍历二叉树

	BSNode<T>* search_recursion(T key);   //递归查找
	BSNode<T>* search_Iterator(T key);      //迭代查找

	T search_mininum();       //查找最小元素
	T search_maxinum();      //查找最大元素

	BSNode<T>* successor(BSNode<T> *x);      //查找指定节点的后继节点
	BSNode<T>* predecessor(BSNode<T> *x);         //查找指定节点的前驱节点

	void insert(T key);     //插入指定值节点
	void remove(T key);     //删除指定值节点
	void destory();      //销毁二叉树
	void print();           //打印二叉树
	

	void CreateBSTree();  //创建二叉树
	void InTreading();//中序遍历线索化

private:
	BSNode<T> *root;    //根节点
private:
	BSNode<T>* search(BSNode<T> *&p, T key);
	void remove(BSNode<T> *p, T key);
	void preOrder(BSNode<T> *p);
	void postOrder(BSNode<T>* p);
	T search_minimun(BSNode<T>* p);
	T search_maximum(BSNode<T>* p);
	void destory(BSNode<T>* &p);
	void InTreading(BSNode<T> *p);
};

//递归创建二叉树
template<typename T>
void BSTree<T>::CreateBSTree(BSNode<T> *x)
{
	T ch;
	cin >> ch;
	if (ch == '#')
		*x = nullptr;
	else{
		*x = new BSNode<T>(ch);
		CreateBSTree(&(*x)->lchild);
		CreateBSTree(&(*x)->rchild);
	}
}


/*中序遍历线索化二叉树
线索化的意义：充分利用空指针，记住结点的前驱、后继（不同遍历次序，前驱后继不同）*/
template<typename T>
void BSTree<T>::InTreading()
{
	InTreading(root);
}
template<typename T>
void BSTree<T>::InTreading(BSNode<T> *p)
{
	BSNode<T> *pre = new BSNode<T>;
	*pre = nullptr;

	if (p)//递归左子树线索化
	{
		InTreading(p->lchild);//没有左孩子
		if (!p->lchild)
		{
			p->LTag = 1;//前驱线索
			p->lchild = pre;//左孩子指针指向前驱
		}
		if (!pre->rchild)//前驱没有右孩子
		{
			pre->RTag = 1;//后继线索
			pre->rchild = p;//前驱右孩子指针指向后继（当前结点p）
		}
		pre = p;//保持pre指向p的前驱
		InTreading(p->rchild);//递归右子树线索化
	}
}


/*插入新节点:
1.如果是空树，则创建一个新节点，新节点作为根
2.寻找元素合适的插入位置：新元素与当前结点进行比较，若值大于当前结点，则从右子树进行寻找；否则从左子树进行寻找.
3.找到插入位置之后，以元素的值构建新节点，插入二叉排序树中*/
template<typename T>
void BSTree<T>::insert(T key)
{
	BSNode<T> *pparent = nullptr;
	BSNode<T> *pnode = root;

	while (pnode != nullptr)         // 寻找合适的插入位置
	{
		pparent = pnode;
		if (key > pnode->value)
			pnode = pnode->rchild;
		else if (key < pnode->value)
			pnode = pnode->lchild;
		else
			break;
	}

	pnode = new BSNode<T>(key);//以元素的值构建新节点
	if (pparent == nullptr)//如果是空树
		pnode = root; //则新节点为根
	else{
		if (key > pparent->value)
			pparent->rchild = pnode;//否则新节点为其父节点的左孩
		else
			pparent->lchild=pnode;//或右孩
	}
	pnode->parent = pparent;//指明新节点的父节点 
}

/*遍历平衡二叉树:前序遍历、中序遍历、后序遍历*/
/*前序遍历:
若二叉树为空，则空操作返回，否则先访问根节点，然后前序遍历左子树，再前序遍历右子树。（简记为：VLR）*/
template<typename T>
void BSTree<T>::preOrder()
{
	preOrder(root);
};
template<typename T>
void BSTree<T>::preOrder(BSNode<T> *p)
{
	if (p != nullptr)
	{
		cout << p->value << " ";
		preOrder(p->lchild);
		preOrder(p->rchild);
	}
	cout << endl;
}

/*中序遍历:
若二叉树为空，则空操作返回，否则从根节点开始，中序遍历根节点的左子树，然后访问根节点，最后中序遍历右子树。（简记为：LVR）*/
template<typename T>
void BSTree<T>::inOrder()
{
	inOrder(root);
}
template<typename T>
void BSTree<T>::inOrder(BSNode<T> *p)
{
	if (p != nullptr)
	{
		inOrder(p->lchild);
		cout << p->value << " ";
		inOrder(p->rchild);
	}
	cout << endl;
}

/*后序遍历:
若树为空，则返回空操作，否则从左到右先叶子后节点的方式遍历访问左右子树，左右子树都访问结束，才访问根节点。（简称LRV）*/
template<typename T>
void BSTree<T>::postOrder()
{
	postOrder(root)
}
template<typename T>
void BSTree<T>::postOrder(BSNode<T>* p)
{
	if (p != nullptr)
	{
		postOrder(p->lchild);
		postOrder(p->rchild);
		cout << p->value << " ";
	}
	cout << endl;
}

/*前驱：中序遍历
1.它有左子树，则左子树根节点为其前驱节点
2.它没有左子树，且它本身为右子树，则其父节点为其前驱节点
3.它没有左子树，且它本身为左子树，则它的前驱节点为“第一个拥有右子树的父节点”*/
template<typename T>
BSNode<T> *BSTree<T>::predecessor(BSNode<T> *pnode)
{
	if (pnode->lchild != nullptr)
	{
		pnode = pnode->lchild;
		while (pnode->lchild != nullptr)
			pnode = pnode->rchild;
		return pnode;
	}

	BSNode<T>* pparent = pnode->parent;
	while (pparent != nullptr && pparent->lchild == pnode)//如果进入循环，则是第三种情况；否则为第二种情况
	{
		pnode = pparent;
		pparent = pparent->parent;
	}
	return pparent;
}

/*后继：中序遍历
1.它有右子树；则其后继节点为其右子树的最左节点
2.它没有右子树，但它本身是一个左孩子，则后继节点为它的双亲
3.它没有右子树，但它本身是一个右孩子，则其后继节点为“具有左孩子的最近父节点”*/
template<typename T>
BSNode<T>* BSTree<T>::successor(BSNode<T> *pnode)
{
	if (pnode->rchild != nullptr)
	{
		pnode = pnode->rchild;
		while (pnode->lchild != nullptr)
			pnode = pnode->lchild;
		return pnode;
	}

	BSNode<T>* pparent = pnode->parent;
	while (pparent != nullptr && pparent->rchild == pnode)//如果进入循环，则是第三种情况；否则为第二种情况
	{
		pnode = pparent;
		pparent = pparent->parent;
	}
	return pparent;
}

/*删除节点：
1.被删除节点同时有左子树与右子树:将前驱节点的值保存在当前结点，继而删除前驱节点
2.被删除节点只有左子树或只有右子树:用子树替换被删节点
3.被删除节点没有子树:直接删除节点*/
template<typename T>
void BSTree<T>::remove(T key)
{
	remove(root, kye);
}
template<typename T>
void BSTree<T>::remove(BSNode<T>* pnode, T key)
{
	if (pnode != nullptr)
	{
		if (pnode->value == key)
		{
			BSNode<T>* pdel == nullptr;

			if (pnode->lchild == nullptr || pnode->rchild == nullptr)//情况2、3,被删除的节点只有左右子树，或者没有孩子
				pdel = pnode;
			else
				pdel = predecessor(pnode);//情况1：被删除的节点同时又左右子树，则将该节点的前驱的值保存到该节点

			//此时，被删除的节点只有一个孩子（或没有孩子），保存该孩子指针
			BSNode<T>* pchild = nullptr;
			if (pdel->lchild != nullptr)
				pchild = pdel->lchild;
			else if (pdel->rchild != nullptr)
				pchild = pdel->rchild;

			//让孩子指向被删除节点的父节点
			if (pchild != nullptr)
				pchild->parent = pdel->parent;

			//如果要删除的节点是头结点，注意更改root的值
			if (pdel->parent == nullptr)
				root = pchild;
			else if (pdel->parent->lchild == pdel)//如果要删除的节点不是头节点，要注意更改它的双亲节点指向新的孩子节点
				pdel->parent->lchild = pchild;
			else if (pdel->parent->rchild == pdel)
				pdel->parent->rchild = pchild;

			if (pnode->value != pdel->value)
				pnode->value = pdel->value;//将前驱的值代替该节点的值

			delete pdel;
		}
		else if (pnode->value > key)
			remove(pnode->lchild, key);
		else
			remove(pnode->rchild, key);
	}
}

/*查找元素：
元素的查找过程与元素的插入过程一致，也是在不断地与当前结点进行比较，若值比当前节点的值大，则在右子树进行查找，
若值比当前节点的值小，则在左子树进行查找，可以看到这是一个很适合递归操作的过程。
而由于二叉排序树这种左小右大的节点特征，也很容易进行非递归查找*/
//非递归
template<typename T>
BSNode<T>* BSTree<T>::search_Iterator(T key)
{
	BSNode<T>* pnode = root;
	while (pnode!=nullptr)
	{
		if (key == pnode->value)//找到
			return pnode;
		else if (key > pnode->value)//大了，在节点右子树查找
			pnode = pnode->rchild;
		else//小了，在节点左子树查找
			pnode = pnode->lchild;
	}
	return nullptr;
}

//递归
template<typename T>
BSNode<T>* BSTree<T>::search_recursion(T key)
{
	return search(root, key);
}
template<typename T>
BSNode<T>* BSTree<T>::search(BSNode<T>* pnode, T key)
{
	if (pnode != nullptr)
	{
		if (key == pnode->value)
			return pnode;
		else if (key > pnode->value)
			return search(pnode->lchild, key);
		else
			return search(pnode->rchild, key);
	}
	else
		return nullptr;
}

//查找最值元素
//最小元素
template<typename T>
T BSTree<T>::search_minimun()
{
	return search_minimun(root);
}
template<typename T>
T BSTree<T>::search_minimun(BSNode<T>* pnode)
{
	if (pnode->lchild != nullptr)
		return search_minimun(pnode->lchild);
	return pnode->value;
}
//最大元素
template<typename T>
T BSTree<T>::search_maximun()
{
	return search_maximun(root);
}
template<typename T>
T BSTree<T>::search_maximun(BSNode<T>* pnode)
{
	if (pnode->rchild != nullptr)
		return search_maximun(pnode->rchild);
	return pnode->value;
}

//销毁二叉树：使用遍历递归销毁二叉树
template<typename T>
void BSTree<T>::destory()
{
	return destory(root);
}
template<typename T>
void BSTree<T>::destory(BSNode<T>* pnode)
{
	if (p != nullptr)//后序
	{
		if (pnode->lchild != nullptr)
			destory(pnode->lchild);
		if (pnode->rchild != nullptr)
			destory(pnode->rchild);
		delete pnode;
		pnode = nullptr;
	}
}
#endif

二叉树遍历（C++版本）
Small_entreprene的博客
08-18 2059
访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。前·中·后序遍历：前序遍历亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。中序遍历访问根结点的操作发生在遍历其左右子树之中（间）。后序遍历访问根结点的操作发生在遍历其左右子树之后。由于被访问的结点必是某子树的根，。NLRLNR和LRN分别又称为先根遍历、中根遍历和后根遍历。相应地，前序、中序和后序遍历都属于。
【数据结构】 二叉树基础详解（C++）
xiatutut的博客
10-21 2100
树：n（n>=0）个结点构成的有限集合。当n=0时，树中没有结点，称为空树。树中有一个根结点其余结点可分为m个互不相交的有限集，每个集合本身也是一棵树，称为原来树的子树。子树是不可以相交的。除了根结点外，每个结点有且仅有一个父结点。一棵有n个结点的树，有n-1条边。因为每个结点都有一条指向它的边，除了根结点。二叉树：n（n>=0）个结点构成的集合。当n=0时，为空树。有且仅有一个称之为根的结点。
二叉树顺序存储结构的基本操作
11-08
http://blog.youkuaiyun.com/ssw_1990/article/details/40511665代码。
二叉树的基本操作(顺序二叉树)
JOKER0707的博客
11-15 336
该代码的二叉树结点是数字，采用的是用数组存储，一般使用在空结点较少的情况，使用的时候，一定要清楚二叉树元素在数组中的存储顺序特点，比如左右子树序号有什么特点，怎么由孩子结点的找到双亲节点…… 如果想了解链式存储二叉树，可以参考http://www.cnblogs.com/-beyond/p/6200478.html #include<iostream> #inclu...
纪念逝去的岁月——C/C++排序二叉树
weixin_33843947的博客
05-26 144
1、代码 2、运行结果 3、分析   1、代码 1 #include &lt;stdio.h&gt; 2 #include &lt;stdlib.h&gt; 3 4 typedef struct _Node 5 { 6 int value; 7 struct _Node * pLeft; 8 struct...
二叉树的基本操作（总结）
ParadiseHeaven的博客
11-21 1251
二叉树的基本操作 二叉树的定义决定了其大多数操作都可以由递归去实现 本文通过递归和非递归两种方式实现二叉树的基本操作（加深对原理的理解） 1.二叉树的声明   typedef char ElementType; typedef struct TreeNode* BinTree; struct TreeNode{ ElementType Data; struct Tre...
二叉树的顺序实现
不忘初心
10-24 589
//完全二叉树最适合用顺序存储实现，其他二叉树也可以，但要做标记，标记某处有没有节点 #include #include #define MAXN 100 int tree[MAXN+1]; int book[MAXN+1]; int main() { memset(book,0,sizeof(book)); for(int i=1;i<=10;i++){ in
C++二叉树基本操作实验报告.doc
最新发布
06-14
最后，通过上述程序设计与分析，我们可以总结出C++实现二叉树基本操作的流程和方法，这不仅涉及到二叉树结构的建立和遍历，还包括如何递归地访问树节点以及如何使用栈来实现非递归遍历等重要技术点。掌握这些内容...
C++二叉树基本操作
09-29
以下是对C++实现的二叉树基本操作的深入分析。 ### 二叉树节点定义 在代码中，二叉树节点`BiNode`被定义为一个结构体，包含三个成员：`data`存储节点的数据，`lchild`指向左子节点，`rchild`指向右子节点。这个...
二叉树的遍历 C++
m0_60284775的博客
03-07 5844
二叉树的遍历有三种： 1.前序遍历：遍历顺序是：先访问根节点，再遍历左子树，最后遍历右子树； 2.中序遍历：遍历顺序是：先遍历左子树，再访问根节点，最后遍历右子树； 3.后序遍历：遍历顺序是：先遍历左子树，再遍历右子树，最后访问根节点。 可以知道的是，无论我们使用哪种遍历方式，其实质都是dfs(深度优先搜索)； 代码实现：（假设已经给出树的序列) 1.前序遍历： #include<iostream> using namespace std; void pre(int a) {
顺序表，链表，二叉树的各种操作
07-07
1、实现对线性表的顺序存储，并实现顺序表的插入、删除、升序合并，逆序操作 2、本程序实现了线性链表的初始化、插入、删除、逆序、排序、合并功能 3、实现二叉树的创建，前中后序遍历，统计叶子数目，求二叉树高度的递归和非递归算法。
顺序二叉树实现
qq_43627100的博客
12-01 186
实现原理：数组下标的2倍为其左儿子，其2倍加一为其右儿子。通过拓展前序序列来输入树。 #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> using namespace std; char a[100001]; int n; void pre(int p)...
顺序二叉树的实现
EVA1992的专栏
03-30 1177
二叉树的顺序结构实现案例
[数据结构]顺序二叉树的实现
Jper_mr的专栏
08-15 2141
顺序二叉树的数据结构为： #define MAX_TREE_SIZE 100; typedef TElemType Btree[MAX_TREE_SIZE ]; Btree bt; 顺序二叉树是用一组地址连续的存储单元依次自上而下自左至右存储完全二叉树上的结点元素，即将完全二叉树上编号为i的结点元素存储在如上定义的一维数组中下标为i-1的分量中。顺序二叉树仅适用于完全二叉树，因为在最坏的情
二叉树顺序结构实现/链式结构实现
haliofwu的专栏
12-10 931
程杰《大话数据结构》这部分的源码乱起八糟的。自己总结下： 顺序结构： #include "stdafx.h" #include "string.h" #include "stdio.h" #include "stdlib.h" #include using namespace std; #define ok 1 #define error 0 #def
数据结构和算法之二叉树的顺序实现和链式实现
five-five
05-28 322
数据结构和算法之二叉树的顺序实现和链式实现二叉树的顺序存储二叉树的链式存储基本实现带父结点的二叉树（三叉链表）总结顺序存储链式存储 二叉树的顺序存储 #define MaxSize 100 struct TreeNode{ ElemType value;//结点中的数据元素 bool isEmpty;//结点是否为空 }; TreeNode t[MaxSize]; 定义一个长度为MaxSize的数组t，按照从上至下、从左至右的顺序依次存储完全二叉树中的各个结点 初始化时所有的结点标记为空 for(
二叉树的排序和实现
沧海一粟的博客
03-28 583
二叉树遍历分为三种先序遍历 首先访问根，再先序遍历左子树，最后先序遍历右子树 根 --> 左 – > 右 无序中序遍历首先中序遍历左子树，再访问根，最后中序遍历右子树 左 --> 根 --.> 右 升序后序遍历首先后序遍历左子树，再后序遍历右子树，最后访问根 左 --> 右 --> 跟 左–>根–>右排序 实现： public class Bin...
二叉树的顺序存储与链式存储（C++）
qq_41185288的博客
07-03 953
//二叉树顺序存储方式：静态数组。 #define MAXSIZE 100 struct TreeNode { //ElemType value; int value; bool isEmpty;//表示结点是否为空 }; //定义树 TreeNode t[MAXSIZE]; //初始化 void InitTreeNode(TreeNode T[]) { for(int i=0;i<MAXSIZE;i++)//TreeNode T[MAXSIZE];i<T.l.
二叉树基本操作c++
03-20
### 二叉树的基本操作及其C++实现 #### 节点创建 在C++中，可以通过结构体`struct`来定义二叉树的节点。每个节点包含三个部分：存储的数据值、指向左子节点的指针和指向右子节点的指针。通过构造函数初始化这些成员变量[^1]。 ```cpp #include <iostream> using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} }; ``` #### 插入节点 为了向二叉树中插入新节点，通常需要递归地找到合适的位置并分配内存给新的节点对象。下面是一个简单的递归插入方法： ```cpp TreeNode* insert(TreeNode* node, int value) { if (node == nullptr) { return new TreeNode(value); } if (value < node->val) { node->left = insert(node->left, value); } else if (value > node->val){ node->right = insert(node->right, value); } return node; } ``` 此代码片段展示了如何基于比较当前节点值与待插入值的关系决定继续往哪个方向深入查找位置[^2]。 #### 遍历方式 遍历是指按照某种顺序访问二叉树中的每一个结点一次的过程。常见的三种主要遍历方式分别为前序遍历、中序遍历以及后序遍历。此外还有层序遍历（广度优先搜索BFS），它按层次从上到下逐层访问所有节点。 ##### 前序遍历（Pre-order Traversal） 前序遍历遵循根-左-右的原则进行访问。 ```cpp void preOrderTraversal(TreeNode *root) { if(root != nullptr){ cout << root->val << " "; // 访问根节点 preOrderTraversal(root->left); // 左子树 preOrderTraversal(root->right); // 右子树 } } ``` ##### 中序遍历（In-order Traversal） 中序遍历则采用左-根-右的方式依次处理各个节点数据项。 ```cpp void inOrderTraversal(TreeNode *root) { if(root != nullptr){ inOrderTraversal(root->left); // 左子树 cout << root->val << " "; // 访问根节点 inOrderTraversal(root->right); // 右子树 } } ``` ##### 后序遍历（Post-order Traversal） 而后序遍历最后才去读取父级的信息，在实际应用当中可能用于释放资源等情况较多见。 ```cpp void postOrderTraversal(TreeNode *root) { if(root != nullptr){ postOrderTraversal(root->left); // 左子树 postOrderTraversal(root->right); // 右子树 cout << root->val << " "; // 访问根节点 } } ``` 以上每种遍历都利用了递归来简化逻辑控制流程的设计思路。 #### 层次遍历（Level Order Traversal 或 BFS 广搜） 不同于上述几种深度优先策略，层次遍历借助队列辅助完成横向扫描动作。 ```cpp #include <queue> void levelOrderTraversal(TreeNode* root) { queue<TreeNode*> q; if(root!=nullptr)q.push(root); while(!q.empty()){ TreeNode* current=q.front();q.pop(); cout<<current->val<<" "; if(current->left!=nullptr)q.push(current->left); if(current->right!=nullptr)q.push(current->right); } } ``` 这段程序首先把初始顶点压栈，之后不断循环直至队列为空为止；每次取出头部元素打印其数值后再将其左右孩子分别加入等待序列之中。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值