二叉树

于 2017-06-23 10:28:49 发布
阅读量150 收藏
点赞数
分类专栏： 数据结构教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/seu_nuaa_zc/article/details/73614073
版权

该篇文章介绍二叉树的一些常用算法。

头文件：BinaryTree.h

#pragma once
#include<iostream>
struct BinaryTreeNode
{
	int                    m_nValue;
	BinaryTreeNode*        m_pLeft;
	BinaryTreeNode*        m_pRight;
};
//===二叉树的基本操作运算
BinaryTreeNode* CreateBinaryTreeNode(int value);//创建一个节点
void ConnectTreeNodes(BinaryTreeNode* pParent, BinaryTreeNode* pLeft, BinaryTreeNode* pRight);//连接根节点和左右子节点

void PrintTreeNode(BinaryTreeNode* pNode);
void PrintTree(BinaryTreeNode* pRoot);//输出节点

void DestroyTree(BinaryTreeNode* pRoot);//销毁节点
BinaryTreeNode *FindNode(BinaryTreeNode*proot, int x);//查找结点
int BinaryTreeHeight(BinaryTreeNode *proot);//求二叉树的高度

//===二叉树的遍历算法--递归版
void PreOrder(BinaryTreeNode *proot);//前序遍历
void InOrder(BinaryTreeNode *proot);//中序遍历
void PostOrder(BinaryTreeNode *proot);//后序遍历

//===二叉树的遍历算法--迭代版
void PreOrderIter(BinaryTreeNode *proot);//前序遍历
void InOrderIter(BinaryTreeNode *proot);//中序遍历
void PostOrderIter(BinaryTreeNode *proot);//后序遍历

//===二叉树的层次遍历
void LevelOrder(BinaryTreeNode *proot);//层次遍历

//===二叉树的其他操作运算--递归版
int NodeCount(BinaryTreeNode *proot);//二叉树的结点个数
void AllLeavesNode(BinaryTreeNode *proot);//求二叉树的所有叶子结点
void CopyOneToAnthor(BinaryTreeNode *proot, BinaryTreeNode *&other);//由一棵二叉树复制产生另一棵二叉树
void ConvertArrayToBT(int a[], int n, int i, BinaryTreeNode *&proot);//由数组转化为二叉树
int Level(BinaryTreeNode *proot, int x, int h);//x所在的层
bool Ancestor(BinaryTreeNode *proot, int x);//输出节点x的所有祖先结点
BinaryTreeNode *ConstructBTbyPreInOrder(int pre[], int prebegin, int mid[], int midbegin, int n);//由前序和中序构造二叉树
BinaryTreeNode *ConstructBTbyPostInOrder(int post[], int postbegin, int mid[], int midbegin, int n);//由后序和中序构造二叉树

//===二叉树的其他操作运算--迭代版
bool AncestorIter(BinaryTreeNode *proot, int x);//输出节点x的所有祖先结点

源文件：BinaryTree.cpp

#include "BinaryTree.h"
#include<iostream>
#include<stack>
#include<queue>
BinaryTreeNode* CreateBinaryTreeNode(int value)
{
	BinaryTreeNode* pNode = new BinaryTreeNode();
	pNode->m_nValue = value;
	pNode->m_pLeft = NULL;
	pNode->m_pRight = NULL;
	return pNode;
}

void ConnectTreeNodes(BinaryTreeNode* pParent, BinaryTreeNode* pLeft, BinaryTreeNode* pRight)
{
	if (pParent != NULL)
	{
		pParent->m_pLeft = pLeft;
		pParent->m_pRight = pRight;
	}
}

void PrintTreeNode(BinaryTreeNode* pNode)
{
	if (pNode != NULL)
	{
		printf("value of this node is: %d\n", pNode->m_nValue);

		if (pNode->m_pLeft != NULL)
			printf("value of its left child is: %d.\n", pNode->m_pLeft->m_nValue);
		else
			printf("left child is null.\n");

		if (pNode->m_pRight != NULL)
			printf("value of its right child is: %d.\n", pNode->m_pRight->m_nValue);
		else
			printf("right child is null.\n");
	}
	else
	{
		printf("this node is null.\n");
	}

	printf("\n");
}

void PrintTree(BinaryTreeNode* pRoot)
{
	PrintTreeNode(pRoot); 

	if (pRoot != NULL)
	{
		if (pRoot->m_pLeft != NULL)
			PrintTree(pRoot->m_pLeft);

		if (pRoot->m_pRight != NULL)
			PrintTree(pRoot->m_pRight);
	}
}

void DestroyTree(BinaryTreeNode* pRoot)
{
	if (pRoot != NULL)
	{
		BinaryTreeNode* pLeft = pRoot->m_pLeft;
		BinaryTreeNode* pRight = pRoot->m_pRight;

		delete pRoot;
		pRoot = NULL;

		DestroyTree(pLeft);
		DestroyTree(pRight);
	}
}

BinaryTreeNode *FindNode(BinaryTreeNode*proot, int x)
{
	if (proot == NULL)
		return NULL;
	else if (proot->m_nValue == x)
		return proot;
	else
	{
		BinaryTreeNode *p = FindNode(proot->m_pLeft, x);
		if (p == NULL)
			return FindNode(proot->m_pRight, x);
		else
			return p;
	}
}

int BinaryTreeHeight(BinaryTreeNode *proot)
{
	if (proot == NULL)
		return 0;
	else 
	{
		int leftheight = BinaryTreeHeight(proot->m_pLeft);
		int righrheight = BinaryTreeHeight(proot->m_pRight);
		return leftheight > righrheight ? leftheight + 1 : righrheight + 1;
	}
}

void PreOrder(BinaryTreeNode *proot)
{
	if (proot)
	{
		std::cout << proot->m_nValue << " ";
		PreOrder(proot->m_pLeft);
		PreOrder(proot->m_pRight);
	}
}

void InOrder(BinaryTreeNode *proot)
{
	if (proot)
	{
		InOrder(proot->m_pLeft);
		std::cout << proot->m_nValue << " ";
		InOrder(proot->m_pRight);
	}
}

void PostOrder(BinaryTreeNode *proot)
{
	if (proot)
	{
		PostOrder(proot->m_pLeft);
		PostOrder(proot->m_pRight);
		std::cout << proot->m_nValue << " ";
	}
}

void PreOrderIter(BinaryTreeNode *proot)
{
	if (proot == NULL)
		return;
	std::stack<BinaryTreeNode*> temp;
	temp.push(proot);
	while (!temp.empty())
	{
		BinaryTreeNode *p = temp.top();
		temp.pop();
		std::cout << p->m_nValue << " ";
		if (p->m_pRight)
			temp.push(p->m_pRight);
		if (p->m_pLeft)
			temp.push(p->m_pLeft);
	}
	std::cout << std::endl;
}

void InOrderIter(BinaryTreeNode *proot)
{
	if (proot == NULL)
		return;
	BinaryTreeNode*p = proot;
	std::stack<BinaryTreeNode *> temp;
	while (!temp.empty()||p!=NULL)
	{
		while (p)
		{
			temp.push(p);
			p = p->m_pLeft;
		}
		if (!temp.empty())
		{
			p = temp.top();
			temp.pop();
			std::cout << p->m_nValue << " ";
			p = p->m_pRight;
		}
	}
	std::cout << std::endl;
}

void PostOrderIter(BinaryTreeNode *proot)
{
	if (proot == NULL)
		return;
	BinaryTreeNode *p = proot, *q = NULL;
	std::stack<BinaryTreeNode*>temp;
	bool flag;
	do
	{
		while (p)
		{
			temp.push(p);
			p = p->m_pLeft;
		}
		q = NULL;
		flag = true;
		while (!temp.empty() && flag)
		{
			p = temp.top();
			if (p->m_pRight == q)
			{
				std::cout << p->m_nValue << " ";
				q = p;
				temp.pop();
			}
			else
			{
				p = p->m_pRight;
				flag = false;
			}
		}
	} while (!temp.empty());

	std::cout << std::endl;
}

void LevelOrder(BinaryTreeNode *proot)
{
	if (proot == NULL)
		return;
	std::queue<BinaryTreeNode*>temp;
	temp.push(proot);

	while (!temp.empty())
	{
		BinaryTreeNode *p = temp.front();
		std::cout << p->m_nValue << " ";
		temp.pop();
		if (p->m_pLeft)
			temp.push(p->m_pLeft);
		if (p->m_pRight)
			temp.push(p->m_pRight);
	}
	std::cout << std::endl;
}

int NodeCount(BinaryTreeNode *proot)
{
	if (proot)
	{
		return 1 + NodeCount(proot->m_pLeft) + NodeCount(proot->m_pRight);
	}
	else
		return 0;
}

void AllLeavesNode(BinaryTreeNode *proot)
{
	if (proot)
	{
		if (proot->m_pLeft == NULL&&proot->m_pRight == NULL)
			std::cout << proot->m_nValue << " ";
		AllLeavesNode(proot->m_pLeft);
		AllLeavesNode(proot->m_pRight);
	}
}

void CopyOneToAnthor(BinaryTreeNode *proot, BinaryTreeNode * &other)
{
	if (proot)
	{
		other = CreateBinaryTreeNode(proot->m_nValue);
		CopyOneToAnthor(proot->m_pLeft, other->m_pLeft);
		CopyOneToAnthor(proot->m_pRight, other->m_pRight);
	}
	else
	{
		other = NULL;
	}
}

void ConvertArrayToBT(int a[], int n,int i,BinaryTreeNode *&proot)
{
	if (i < n)
	{
		proot = CreateBinaryTreeNode(a[i]);
		ConvertArrayToBT(a, n, i * 2 + 1, proot->m_pLeft);
		ConvertArrayToBT(a, n, i * 2 + 2, proot->m_pRight);
	}
	else
		proot = NULL;
}

int Level(BinaryTreeNode *proot, int x, int h)
{
	if (proot == NULL)
		return 0;

	if (proot->m_nValue == x)
		return h;
	else
	{
		int height = Level(proot->m_pLeft, x, h + 1);
		if (height != 0)
			return height;
		else
			return Level(proot->m_pRight, x, h + 1);
	}
}

bool Ancestor(BinaryTreeNode *proot, int x)
{
	if (proot == NULL)
		return false;
	if (proot->m_pLeft != NULL&&proot->m_pLeft->m_nValue == x)
	{
		std::cout << proot->m_nValue << " ";
		return true;
	}
	if (proot->m_pRight != NULL&&proot->m_pRight->m_nValue == x)
	{
		std::cout << proot->m_nValue << " ";
		return true;
	}
	if (Ancestor(proot->m_pLeft, x) || Ancestor(proot->m_pRight, x))
	{
		std::cout << proot->m_nValue << " ";
		return true;
	}
	else
		return false;
}

BinaryTreeNode *ConstructBTbyPreInOrder(int pre[], int prebegin, int mid[], int midbegin, int n)
{
	if (n <= 0)
		return NULL;
	BinaryTreeNode *proot = CreateBinaryTreeNode(pre[prebegin]);
	int index;
	for (int i = midbegin; i < midbegin + n; i++)
	{
		if (pre[prebegin] == mid[i])
		{
			index = i;
			break;
		}
	}
	int k = index - midbegin;
	proot->m_pLeft = ConstructBTbyPreInOrder(pre, prebegin + 1, mid, midbegin,k);
	proot->m_pRight = ConstructBTbyPreInOrder(pre, prebegin+k + 1, mid, index + 1, n - k-1);
	return proot;
}

BinaryTreeNode *ConstructBTbyPostInOrder(int post[], int postbegin, int mid[], int midbegin, int n)
{
	if (n <= 0)
		return NULL;
	
	BinaryTreeNode *proot = CreateBinaryTreeNode(post[postbegin + n - 1]);
	int index;
	for (int i = midbegin;i < midbegin + n; i++)
	{
		if (post[postbegin + n - 1] == mid[i])
		{
			index = i;
			break;
		}
	}
	int k = index - midbegin;
	proot->m_pLeft = ConstructBTbyPostInOrder(post, postbegin, mid, midbegin, k);
	proot->m_pRight = ConstructBTbyPostInOrder(post, postbegin+k, mid, index + 1, n - k- 1);
	return proot;
}
bool AncestorIter(BinaryTreeNode *proot, int x)
{
	if (proot == NULL)
		return false;

	BinaryTreeNode *p = proot, *q = NULL;
	std::stack<BinaryTreeNode*>temp;
	bool flag;
	do
	{
		while (p)
		{
			temp.push(p);
			p = p->m_pLeft;
		}
		q = NULL;
		flag = true;
		while (!temp.empty() && flag)
		{
			p = temp.top();
			if (p->m_nValue == x)
			{
				temp.pop();
				while (!temp.empty())
				{
					std::cout << temp.top()->m_nValue << " ";
					temp.pop();
				}
				return true;
			}
			else
			{
				if (p->m_pRight == q)
				{
					q = p;
					temp.pop();
				}
				else
				{
					p = p->m_pRight;
					flag = false;
				}
			}
		}
	} while (!temp.empty());

	std::cout << std::endl;
	return false;
}

主函数：main.cpp

#include "BinaryTree.h"
#include<iostream>
using namespace std;
// ====================测试代码====================
//            8
//        6      10
//       5 7    9  11
int main()
{
	//===
	BinaryTreeNode* pNode8 = CreateBinaryTreeNode(8);
	BinaryTreeNode* pNode6 = CreateBinaryTreeNode(6);
	BinaryTreeNode* pNode10 = CreateBinaryTreeNode(10);
	BinaryTreeNode* pNode5 = CreateBinaryTreeNode(5);
	BinaryTreeNode* pNode7 = CreateBinaryTreeNode(7);
	BinaryTreeNode* pNode9 = CreateBinaryTreeNode(9);
	BinaryTreeNode* pNode11 = CreateBinaryTreeNode(11);
	ConnectTreeNodes(pNode8, pNode6, pNode10);
	ConnectTreeNodes(pNode6, pNode5, pNode7);
	ConnectTreeNodes(pNode10, pNode9, pNode11);
	//===============二叉树的基本操作运算==================
	//输出二叉树===
	//PrintTree(pNode8);
	
	//查找结点===
	//int findnode = 10;
	//BinaryTreeNode *findres = FindNode(pNode8, findnode);
	//if (findres) cout << findres->m_nValue << endl;

	//二叉树的高度===
	//int btheight = BinaryTreeHeight(pNode8);
	//cout << "二叉树的高度:" << btheight << endl;
	
	//===============二叉树的遍历-递归版=================
	//前序遍历===
	//PreOrder(pNode8);cout << endl;
	//中序遍历===
	//InOrder(pNode8); cout << endl;
	//后序遍历===
	//PostOrder(pNode8); cout << endl;

	//===============二叉树的遍历-迭代版=================
	//前序遍历===
	//PreOrderIter(pNode8);
	//中序遍历===
	//InOrderIter(pNode8); 
	//后序遍历===
	//PostOrderIter(pNode8); 

	//================二叉树的层次遍历===================
	//LevelOrder(pNode8);

	//==================二叉树的其他操作运算--递归版======
	//二叉树的结点个数===
	//int nodecount = NodeCount(pNode8);
	//cout << nodecount << endl;

	//二叉树的所有叶子结点===
	//AllLeavesNode(pNode8);

	//二叉树的复制===
	//BinaryTreeNode *other = NULL;
	//CopyOneToAnthor(pNode8, other);
	//PrintTree(other);
	//DestroyTree(other);

	//由数组转化为二叉树===
	//const int n = 7;
	//int a[n] = { 8, 6, 10, 5, 7, 9, 11 };
	//BinaryTreeNode *proot = NULL;
	//ConvertArrayToBT(a, n, 0, proot);
	//PrintTree(proot);
	//DestroyTree(proot);

	//x所在的层
	//int x = 0;
	//int height = Level(pNode8, x, 1);
	//cout << height << endl;

	//输出x的祖先结点
	//int x = 8;
	//Ancestor(pNode8, x);

	//由前序和中序构造二叉树===
	const int n = 7;
	int pre[n] = { 8, 6, 5, 7, 10, 9, 11 };
	int mid[n] = { 5, 6, 7, 8, 9, 10, 11 };
	int post[n] = { 5, 7, 6, 9, 11, 10, 8 };
	
	//BinaryTreeNode *proot1 = ConstructBTbyPreInOrder(pre, 0, mid, 0, n);
	//PrintTree(proot1);
	//DestroyTree(proot1);
	
	//由后序和中序构造二叉树===
	//BinaryTreeNode *proot2 = ConstructBTbyPostInOrder(post, 0, mid, 0, n);
	//PrintTree(proot2);
	//DestroyTree(proot2);

	//====================二叉树的其他操作运算--迭代版======
	//输出x的祖先结点
	//int x = 9;
	//AncestorIter(pNode8, x);



	//销毁二叉树===
	DestroyTree(pNode8);
}


seu_nuaa_zc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树 基础
03-08
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树...
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
平衡二叉树
03-03
平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，平衡二叉树Java实现，
将满二叉树转化为求和二叉树_二叉树_
09-30
输入共3行：第一行为满二叉树中结点个数n（n<1024）；第二行为n个整数，表示二叉树的先序遍历序列；第三行也有n个整数，表示二叉树的中序遍历序列。整数间以空格分割。
线索二叉树
04-10
通过前序序列创建线索二叉树 1:中序遍历 2:查找节点前驱后继 3:插入节点 4:删除节点 0:退出
队列的应用——求解迷宫问题
seu_nuaa_zc的博客
06-13 4698
代码示例： #include using namespace std; const int MaxSize = 20; //迷宫最大行、列数 const int QueueSize = 100; //顺序队大小 struct Box //方块结构体类型 { int i; //方块的行号 int j; //方块的列号 int pre;
栈的应用——求解迷宫问题
seu_nuaa_zc的博客
06-13 2505
问题描述: 给定一个M×N的迷宫图，求一条从指定入口到出口的路径。假设迷宫图如图所示（M=10，N=10），其中的方块图表示迷宫。对于图中的每个方块，用空白表示通道，用阴影表示墙。要求所求路径必须是简单路径，即在求得的路径上不能重复出现同一通道块。 数据组织:为了表示迷宫，设置一个数组a，其中每个元素表示一个方块的状态，为0时表示对应方块是通道，为1时表示对应方块不可走。为了算法方便，在一
线性表的应用——求解两个多项式相加问题描述（顺序表求解）
seu_nuaa_zc的博客
06-13 2183
问题描述： 假设一个多项式形式为：p(x)=c1*x^(e1)+c2*x^(e2)+...+cm*x^(em)；其中ei（1≤i≤m）为整数类型的指数，并且没有相同指数的多项式项；ci（1≤i≤m）为实数类型的序数。 编写求两个多项式相加的程序。 代码示例： #include using namespace std; const int MaxSize = 20; struct Poly
串——链式存储结构
seu_nuaa_zc的博客
06-16 1346
该文章主要介绍串的链式存储结构以及相关运算。 头文件：LinkString.h #ifndef LINKSTRING_H_ #define LINKSTRING_H_ #include struct LinkNode //链串结点类型 { char data; //存放一个字符 LinkNode *next; //指向下一个结点 }; class LinkStrin
队列——链式存储结构及其基本运算（链队列的另一种表达方式）
seu_nuaa_zc的博客
06-13 1315
问题描述：采用一个不带头结点只有一个尾结点指针rear的循环单链表存储队列，设计出这种链队的进队、出队、判队空和求队中元素个数的算法。  代码示例： #include using namespace std; template struct LinkNode //链队数据结点类型 { T data; //结点数据域 LinkNode *next; //指
栈——顺序存储结构及其基本运算
seu_nuaa_zc的博客
06-12 1266
该文章主要介绍栈的顺序存储结构以及相关运算。 头文件：SqStack.h template class SqStackClass //顺序栈类 { T *data; //存放栈中元素 int top; //栈顶指针 public: //===============顺序栈的基本运算算法====================== SqStackCla
队列——顺序存储结构及其基本运算（循环队列的另一种表达方式）
seu_nuaa_zc的博客
06-13 1231
问题描述：对于循环队列来说，如果知道队头指针和队列中元素个数，则可以计算出队尾指针。也就是说，可以用队列中元素个数代替队尾指针。设计出这种循环队列的进队、出队、判队空和求队中元素个数的算法。 示例代码： #include using namespace std; const int MaxSize = 5; //队大小 template class SqQueueClass2 /
队列——链式存储结构及其基本运算
seu_nuaa_zc的博客
06-13 983
该文章主要介绍队列的链式存储结构以及相关运算。 头文件：LinkQueue.h template struct LinkNode //链队数据结点类型 { T data; //结点数据域 LinkNode *next; //指向下一个结点 }; template struct LinkQueue //链队结点类型 { LinkNode *front;
栈的应用——求解简单算术表达式值
seu_nuaa_zc的博客
06-13 806
问题描述： 这里限定的简单算术表达式求值问题是：用户输入一个包含“+”、“-”、“*”、“/”、正整数和圆括号的合法数学表达式，计算该表达式的运算结果。如：“2+4*(5-1)”=18。 代码示例： #include #include "SqStack.cpp" //包含顺序栈类模板 using namespace std; class ExpressClass //求表
队列——顺序存储结构及其基本运算（循环队列）
seu_nuaa_zc的博客
06-13 797
该文章主要介绍循环队列的顺序存储结构以及相关运算。 头文件：CSqQueue.h template class SqQueueClass1 //循环队列类模板 { T *data; //存放队中元素 int front, rear; //队头和队尾指针 public: //================循环队基本运算算法=====================
线性表——链式存储结构之双链表的应用
seu_nuaa_zc的博客
06-09 721
题目： 设有一个双链表对象L，每个结点中除有prior、data和next这3个域外，还有一个访问频度域freq，在链表被起用之前，其值均初始化为零。每当进行LocateElem1(e)运算时，令元素值为e的结点中freq域的值加1，并调整表中结点的次序，使其按访问频度的递减序排列，以便使频繁访问的结点总是靠近表头。设计满足上述要求的LocateElem1算法和完整的程序，并用相关数据进行测试。
线性表的应用——求解两个多项式相加问题描述（链表求解）
seu_nuaa_zc的博客
06-12 610
问题描述：假设一个多项式形式为：p(x)=c1*x^(e1)+c2*x^(e2)+...+cm*x^(em)；其中ei（1≤i≤m）为整数类型的指数，并且没有相同指数的多项式项；ci（1≤i≤m）为实数类型的序数。 编写求两个多项式相加的程序。 示例代码： #include using namespace std; const int MAX = 10; struct PolyNode
稀疏矩阵
seu_nuaa_zc的博客
06-16 531
该文章介绍稀疏矩阵的相关用法。 头文件：SMatrix.h #include const int MAXR = 20; //稀疏矩阵最大行数 const int MAXC = 20; //稀疏矩阵最大列数 const int MaxSize = 100; //三元组顺序表最大元素个数 struct TupNode //单个三元组的类型 { int r; //行号 int
二叉树chuangjian
最新发布
09-20
二叉树是一种常见的数据结构，由节点和边组成。每个节点最多有两个子节点，分别称为左子节点和右子节点。 创建二叉树的方法有多种。一种常用的方法是使用链式存储结构，即每个节点含有数据和指向左右子节点的指针。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值