二叉链表存储树

最新推荐文章于 2025-03-24 11:51:57 发布
最新推荐文章于 2025-03-24 11:51:57 发布
阅读量2k 收藏 4
点赞数
分类专栏： 代码 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/good18Levin/article/details/120818137
版权
本文详细介绍了二叉树的各种遍历方法（先序、中序、后序、非递归）及其应用，如层序遍历、创建二叉树、求叶子节点个数、树的高度等。同时，还涵盖了二叉树的其他操作，如求最大宽度、构建特定遍历序列的二叉树、找到两个节点的最近公共祖先等。

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

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<iostream>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<algorithm>
using namespace std;
typedef int DataType;
typedef struct BiTNode {
	DataType data;
	struct BiTNode *LChild;
	struct BiTNode *RChild;
}BiTNode, *BiTree;

//**************************************************
//有关栈的部分
#define MAXSIZE 100
#define  OK 1
#define ERROR 0
typedef BiTNode* Elemtype;
typedef struct {
	Elemtype data[MAXSIZE];
	int top;
}SeqStack;

void InitStack(SeqStack *S)
{
	S->top = -1;
}

int StackEmpty(SeqStack S) {
	return S.top == -1;
}

int StackFull(SeqStack S)
{
	return S.top == MAXSIZE - 1;
}

int PushStack(SeqStack *S, Elemtype e)
{
	if (!StackFull(*S)) {
		S->data[++S->top] = e;
		return OK;
	}
	else
		return ERROR;
}

int PopStack(SeqStack *S, Elemtype* x)
{
	if (!StackEmpty(*S)) {
		*x = S->data[S->top--];
		return OK;
	}
	else {
		printf("栈为空\n");
		return ERROR;
	}
}

int GetTop(SeqStack *S, Elemtype *x)
{
	if (!StackEmpty(*S)) {
		*x = S->data[S->top];
		return OK;
	}
	else {
		printf("栈为空!\n");
		return ERROR;
	}
}

//**************************************************************************************

//***************************************************************************************
//队列相关的代码
typedef BiTNode * QueueElemType;
typedef struct{
	QueueElemType element[MAXSIZE];
	int top;
	int rear;
}SeqQueue;

void InitSeqQueue(SeqQueue *Q) {
	Q->top = 0;
	Q->rear = 0;
}

int IsEmpty(SeqQueue Q)
{
	if (Q.rear == Q.top)
		return 1;
	else
		return 0;
}

int IsFull(SeqQueue Q)
{
	if ((Q.rear + 1) % MAXSIZE == Q.top)
		return 1;
	else
		return 0;
}

int EnterQueue(SeqQueue *Q, QueueElemType x)
{
	if ((Q->rear + 1) % MAXSIZE == Q->top)
		return 0;
	Q->element[Q->rear] = x;
	Q->rear = (Q->rear + 1) % MAXSIZE;
	return 1;
}

int DeleteQueue(SeqQueue *Q, QueueElemType *x)
{
	if (Q->rear == Q->top)
		return 0;
	*x = Q->element[Q->top];
	Q->top = (Q->top + 1) % MAXSIZE;
	return 1;
}

//**************************************************************************************
//拓展先序创建二叉树
void CreateBiTree(BiTree *root)
{
	int num;
	scanf("%d", &num);
	if (num == 9999) *root = NULL;
	else {
		*root = (BiTNode *)malloc(sizeof(BiTNode));
		(*root)->data = num;
		CreateBiTree(&((*root)->LChild));
		CreateBiTree(&((*root)->RChild));
	}
}

void visit(int data)
{
	printf("%5d", data);
}

//先序遍历递归和非递归
void preOrder(BiTree root)
{
	if (root != NULL) {
		visit(root->data);
		preOrder(root->LChild);
		preOrder(root->RChild);
	}
}

//利用栈来实现前序
void preOrderNR(BiTree root)
{
	SeqStack s;
	InitStack(&s);
	BiTNode * p = root;
	if (!p) return;
	//只要左孩子不为空，就一直入栈，否则退栈访问右孩子
	while (!StackEmpty(s) || p) {
		if (p != NULL) {
			visit( p->data);
			PushStack(&s, p);
			p = p->LChild;
		}
		else {
			PopStack(&s, &p);
			p = p->RChild;
		}
	}
}

//中序遍历递归和非递归
void InOrder(BiTree root)
{
	if (root != NULL) {
		InOrder(root->LChild);
		visit(root->data);
		InOrder(root->RChild);
	}
}

void InOrderNR(BiTree root)
{
	SeqStack s;
	InitStack(&s);
	BiTNode *p = root;
	while (p!=NULL || !StackEmpty(s)) {
		if (p != NULL) {
			PushStack(&s, p);
			p = p->LChild;
		}
		else {
			PopStack(&s, &p);
			visit(p->data);
			p = p->RChild;
		}
	}
}

//后续遍历递归和非递归
void postOrder(BiTree root)
{
	if (root != NULL) {
		postOrder(root->LChild);
		postOrder(root->RChild);
		visit(root->data);
	}
}

void postOrderNR(BiTree root)
{
	SeqStack s;
	InitStack(&s);
	BiTNode * p = root, *pre = NULL;
	while (!StackEmpty(s) || p) {

		if (p != NULL) {
			PushStack(&s, p);
			p = p->LChild;
		}else{
			GetTop(&s, &p);
			if (p->RChild == NULL || p->RChild == pre) {
				PopStack(&s, &p);
				visit(p->data);
				pre = p;
				p = NULL;
			}
			else {
				p = p->RChild;
			}
		}
	}
}

//求叶子结点个数
int  CountLeaf(BiTree root)
{
	if (root == NULL) return 0;
	if (root->LChild == NULL && root->RChild == NULL)
		return 1;
	else
		return CountLeaf(root->LChild) + CountLeaf(root->RChild);
}

int totalLeaf = 0;
void CountLeaf2(BiTree root)
{
	if (root != NULL) {
		if (!root->LChild && !root->RChild) {
			totalLeaf++;
		}
		CountLeaf2(root->LChild);
		CountLeaf2(root->RChild);
	}
}


//求树的高度
int treeHeight(BiTree root)
{
	int hl, hr, maxh;
	if (root != NULL) {
		hl = treeHeight(root->LChild);
		hr = treeHeight(root->RChild);
		maxh = (hl > hr ? hl: hr) + 1;
		return maxh;
	}
	else
		return 0;
}


int height = 0;
void treeHeight2(BiTree root, int h)
{
	if (root != NULL) {
		if (h > height) height = h;
		treeHeight2(root->LChild, h + 1);
		treeHeight2(root->RChild, h + 1);
	}
}


//横向打印二叉树
void HorizontalPrint(BiTree root ,int layer)
{
	if (root != NULL) {
		HorizontalPrint(root->RChild, layer + 1);
		for (int i = 0; i < layer; i++)
			printf("  ");
		printf("%d\n", root->data);
		HorizontalPrint(root->LChild, layer + 1);
	}
}


//层序遍历
int LayerOrder(BiTree root)
{
	SeqQueue Q;
	InitSeqQueue(&Q);
	BiTNode * p = root;
	if (p == NULL) return 0;
	EnterQueue(&Q, p);
	while (!IsEmpty(Q)) {
		DeleteQueue(&Q, &p);
		visit(p->data);
		if (p->LChild)
			EnterQueue(&Q, p->LChild);
		if (p->RChild)
			EnterQueue(&Q, p->RChild);
	}
	return 1;
}

//获取一个整数的数字个数
int CountDigit(int data)
{
	string dataStr = to_string(data);
	return dataStr.length() ;
}

typedef struct NewNode{
	BiTNode * treePart;
	int countDigit;
}NewNode;


//中序遍历获取序列
void InOrder2(BiTree root, string &InStr, vector<NewNode> &data) {
	if (root != NULL) {
		InOrder2(root->LChild, InStr,data);
		InStr += to_string(root->data);
		NewNode nn;
		nn.treePart = root;
		nn.countDigit = CountDigit(root->data);
		data.push_back(nn);
		InOrder2(root->RChild, InStr, data);
	}
}

//竖形打印
void PrintVertically(BiTree root)
{
	queue<BiTNode*> q;
	if (root == NULL)
	{
		printf("\nThe tree is empty.\n");
		return;
	}
	string InStr;
	vector<NewNode> data;
	InOrder2(root, InStr,data);

	q.push(root);
	while (!q.empty()) {
		vector<BiTNode*> cache;
		while (!q.empty()) {
			cache.push_back(q.front());
			q.pop();
		}

		string line = "";
		for (int i = 0; i < InStr.length(); i++)
			line += " ";

		for (auto p : cache) {
			if (p) {
				int totalDigits = 0;
				for (int i = 0; i < data.size(); i++) {
					if (data[i].treePart == p)
						break;
					totalDigits += data[i].countDigit;
				}
				for (int i = totalDigits; i < totalDigits + CountDigit(p->data); i++)
					line[i] = InStr[i];
				if (p->LChild) q.push(p->LChild);
				if (p->RChild)  q.push(p->RChild);
			}
		}

		cout << line << endl;
	}
}

//查找根结点到目标结点的路径，并将其存储在stack中
void Path(BiTree root, BiTNode * r , stack<BiTNode *> &s)
{
	if (root == NULL) return;
	BiTNode *p = root, *q = NULL;
	while (p != NULL || !s.empty()) {
		if (p) {
			s.push(p);
			p = p->LChild;
		}
		else {
			p = s.top();
			if (p->RChild == NULL || p->RChild == q) {
				if (p == r)
					return;
				q = p;
				s.pop();
				p = NULL;
			}
			else
				p = p->RChild;
		}
	}
}

//将栈的元素反过来装入
stack<BiTNode*> ReverseStack(stack<BiTNode*> s)
{
	stack<BiTNode*> s1;
	while (!s.empty()) {
		s1.push(s.top());
		s.pop();
	}
	return s1;
}

//查找二叉树两结点的共同祖先
BiTNode * FindCommonAncestor(BiTree root, BiTNode *p, BiTNode *q) {
	stack<BiTNode *> s1, s2;

	Path(root, p, s1);
	if (s1.empty()) {
		printf("p指针不是二叉树中的有效指针\n");
		return NULL;
	}
	s1 = ReverseStack(s1);
	Path(root, q, s2);
	if (s2.empty()) {
		printf("q指针不是二叉树中的有效指针\n");
		return NULL;
	}
	s2 = ReverseStack(s2);

	BiTNode *pre = NULL;
	while (!s1.empty() && !s2.empty()) {
		if (s1.top() == s2.top()) {
			pre = s1.top();
			s1.pop();
			s2.pop();
		}
		else
			break;
	}
	return pre;
}

//计算非叶子结点的个数
int CountNoLeaf(BiTree root)
{
	static int num = 0;
	if (root != NULL) {
		if (root->LChild != NULL || root->RChild != NULL)
			num++;
		CountNoLeaf(root->LChild);
		CountNoLeaf(root->RChild);
	}
	return num;
}

void DelSubTree(BiTree &root)
{
	if (root == NULL) return;
	DelSubTree(root->LChild);
	DelSubTree(root->RChild);
	free(root);
}

//删去二叉树每一个以X为根结点的子树，并释放它们的空间
void DelXSubTree(BiTree &root, DataType x)
{
	if (root != NULL) {
		if (root->data == x) {
			DelSubTree(root);
			root = NULL;//删除后将被删除的引用改为NULL
		}
		else {
			/*if (root->LChild && root->LChild->data == x)
				root->LChild = NULL;
			if (root->RChild && root->RChild->data == x)
				root->RChild = NULL;*/
			DelXSubTree(root->LChild, x);
			DelXSubTree(root->RChild, x);
		}
	}
}

void DelXSubTree2(BiTree &root, DataType x)
{
	if (root != NULL) {
		if (root->LChild && root->LChild->data == x) {
			DelSubTree(root->LChild);
			root->LChild = NULL;
		}
		if (root->RChild && root->RChild->data == x) {
			DelSubTree(root->RChild);
			root->RChild = NULL;
		}
		if (root->data == x) {
			DelSubTree(root);
			root = NULL;
		}
	}
}

//判断一棵二叉树是否是正则二叉树
//正则二叉树是指在二叉树中不存在子树个数为1的结点
bool IsRegular = true;
void IsRegularTree(BiTree root)
{
	if (root != NULL) {
		bool flag1 = (root->LChild == NULL);
		bool flag2 = (root->RChild == NULL);
		if ((flag1 && !flag2) || (!flag1 && flag2))
			IsRegular = false;
		IsRegularTree(root->LChild);
		IsRegularTree(root->RChild);
	}
}

bool IsRegularTree2(BiTree root)
{
	if (root == NULL)
		return true;
	else if (root->LChild == NULL && root->RChild == NULL)
		return true;
	else if (root->LChild == NULL || root->RChild == NULL)
		return false;
	else{
		bool  isRegularLeft = IsRegularTree2(root->LChild);
		bool isRegularRight = IsRegularTree2(root->RChild);
		return isRegularLeft && isRegularRight;
	}
}

int CountOneNode(BiTree root)
{
	static int num = 0;
	if (root != NULL) {
		if (root->LChild && !root->RChild || root->RChild && !root->LChild)
			num++;
		CountOneNode(root->LChild);
		CountOneNode(root->RChild);
	}
	return num;
}

bool IsRegularTree3(BiTree root)
{
	int numberOneNode = CountOneNode(root);

	if (numberOneNode != 0)
		return false;
	else
		return true;
}

//判断一棵树是不是完全二叉树
//判断方法：利用层序遍历，不过即使是空的孩子结点也要入队列;
                    //当从队列中取出一个空结点，其后续取出的所有结点必然也是空节点
int IsCompleteTree(BiTree root)
{
	if (root == nullptr)
		return 1;
	queue<BiTNode*> q;
	q.push(root);
	BiTNode *p = root;
	while (!q.empty() || p) {
		p = q.front();
		q.pop();
		if (p) {
			q.push(p->LChild);
			q.push(p->RChild);
		}
		else {
			while (!q.empty()) {
				p = q.front();
				q.pop();
				if (p)
					return 0;
			}
		}
	}
	return 1;
}

typedef struct {
	BiTNode * data[MAXSIZE];
	int level[MAXSIZE];
	int rear, front;
}Qu;
//求一颗二叉树的最大宽度
//思路：利用队列层序遍历二叉树，并将结点指针和对应层号保存，
//   然后依次从队列中取出元素并计算每个层次的个数
// 取其最大值即可得到最大宽度
int MaxWidth(BiTree root)
{
	if (root == NULL) {
		printf("空树\n");
		return 0;
	}
	Qu qu;
	qu.rear = qu.front = -1;
	//加入第一个结点
	BiTNode * p = root;
	qu.data[++qu.rear] = p;
	qu.level[qu.rear] = 1;//对应于同一个下标，这里的qu.rear不用再自增1了
	int curLevel;
	//取出当前结点和其层次号，加入子结点并且层次号加1
	while (qu.front < qu.rear) {
		p = qu.data[++qu.front];
		//这里的++front是逻辑上的出队列，但是结点指针和层次数据却已经保存下来了
		curLevel = qu.level[qu.front];
		if (p->LChild) {
			qu.data[++qu.rear] = p->LChild;
			qu.level[qu.rear] = curLevel + 1;
		}
		if (p->RChild) {
			qu.data[++qu.rear] = p->RChild;
			qu.level[qu.rear] = curLevel + 1;
		}
	}
	//遍历队列的level数组，依次统计各个层次的个数，找到其中的最大值以及层次总数
	int layer = 1, maxWidth = 0, count = 0;
	int curLayerNum;
	while (count <= qu.rear) {
		curLayerNum = 0;

		while (count <= qu.rear && qu.level[count] == layer) {
			count++;
			curLayerNum++;
		}

		layer = qu.level[count];
		if (curLayerNum > maxWidth)
			maxWidth = curLayerNum;
	}
	return maxWidth;
}


//采用递归算法，交换一棵树所有结点的所有子树
//前中后序均可以
void  SwapChildren(BiTree root)
{
	if (root != NULL) {
		SwapChildren(root->LChild);
		SwapChildren(root->RChild);

		BiTNode * temp = root->LChild;
		root->LChild = root->RChild;
		root->RChild = temp;
	}
}

//计算一个给定二叉树双分支结点的个数
int Count2BranchNode(BiTree root)
{
	if (root == NULL)
		return 0;
	else if (root->LChild && root->RChild)
		return Count2BranchNode(root->LChild) + Count2BranchNode(root->RChild) + 1;
	else
		return Count2BranchNode(root->LChild) + Count2BranchNode(root->RChild);
}

//使用非递归算法查找后续遍历的第一个结点
BiTNode * LDRFirstNode(BiTree root)
{
	if (root == NULL) {
		printf("空树，不存在第一个结点\n");
		return NULL;
	}
	BiTNode * p = root;
	while (p != NULL && (p->LChild != NULL || p->RChild != NULL)) {
		if (p->LChild != NULL)
			p = p->LChild;
		else
			p = p->RChild;
	}
	return p;
}

//将二叉树的叶子结点串联成一个单链表，表头指针为head
BiTNode  *pre = NULL;
BiTNode * head = NULL;
void LeafLink(BiTree root)
{
	if (root != NULL) {
		if (root->LChild == NULL && root->RChild == NULL) {
			if (pre == NULL)
				head = root;
			else
				pre->RChild = root;
			pre = root;
		}
		LeafLink(root->LChild);
		LeafLink(root->RChild);
	}
}

//设有一个满二叉树（所有结点的值均不相同），已知其先序序列为pre,求其后序序列
void GetPostSeqFromPre(int preSeq[], int low, int high, vector<int> &postSeq)//默认数组从0到n-1存取
{
	int rootIndex = low, halfLen = (high - low) / 2;
	if (low < high) {
		GetPostSeqFromPre(preSeq, low + 1, low + halfLen, postSeq);
		GetPostSeqFromPre(preSeq, low + halfLen + 1, high, postSeq);
	}
	postSeq.push_back(preSeq[rootIndex]);
}

//根据先序序列和中序序列创建二叉树
void CreateTreePreMid(BiTree *root , DataType pre[] , int l1, int h1, DataType mid[], int l2, int h2)
{
	if (l1 <= h1) {
		*root = (BiTNode *)malloc(sizeof(BiTNode));
		(*root)->data = pre[l1];

		int midIndex = 0;
		for (int i = l2; i <= h2; i++)
			if (mid[i] == pre[l1])
				midIndex = i;
		int leftLen = midIndex - l2, rightLen = h2 - midIndex;

		CreateTreePreMid(&((*root)->LChild), pre, l1 + 1, l1 + leftLen, mid, l2, l2 + leftLen - 1);
		CreateTreePreMid(&((*root)->RChild), pre, h1 - rightLen + 1, h1, mid, h2 - rightLen + 1, h2);
	}
	else {
		*root = NULL;
	}
}

void CreateTreePreMid2(BiTree &root, DataType pre[], int l1, int h1, DataType mid[], int l2, int h2)
{
	if (l1 <= h1) {
		root = (BiTNode *)malloc(sizeof(BiTNode));
		root->data = pre[l1];

		int midIndex = 0;
		for (int i = l2; i <= h2; i++)
			if (mid[i] == pre[l1])
				midIndex = i;
		int leftLen = midIndex - l2, rightLen = h2 - midIndex;

		CreateTreePreMid2(root->LChild, pre, l1 + 1, l1 + leftLen, mid, l2, l2 + leftLen - 1);
		CreateTreePreMid2(root->RChild, pre, h1 - rightLen + 1, h1, mid, h2 - rightLen + 1, h2);
	}
	else {
		root = NULL;
	}
}

//根据中序序列和后序序列创建二叉树
void CreateTreeMidPost(BiTree &root, DataType mid[], int l1, int h1, DataType post[], int l2, int h2)
{
	if (l1 <= h1) {
		root = (BiTNode *)malloc(sizeof(BiTNode));
		root->data = post[h2];

		int midIndex = 0;
		for (int i = l1; i <= h1; i++)
			if (mid[i] == post[h2])
				midIndex = i;

		int leftLen = midIndex - l1;
		int rightLen = h1 - midIndex;
		CreateTreeMidPost(root->LChild, mid, l1, midIndex - 1, post, l2, l2 + leftLen - 1);//注意这部分前面不要写错l和h
		CreateTreeMidPost(root->RChild, mid, midIndex + 1, h1, post, l2 +leftLen, h2-1);
	}
	else {
		root = NULL;//一定记的要置为NULL
	}
}

//根据层序和中序序列建立二叉树
//层序号可以确认第一个是根结点，然后根据中序序列可以得到左子树和右子树的结点分别是什么，
//然后再层序遍历中依次判断其在中序对应的左子树还是右子树中，将其按照左右子树分开，
//按照顺序依次连接就可以得到左子树和右子树的层序遍历序列
//创建新结点的函数
BiTree NewBiTNode(DataType val)
{
	BiTNode * newBiTNode = new BiTNode;
	newBiTNode->data = val;
	newBiTNode->LChild = NULL;
	newBiTNode->RChild = NULL;
	return newBiTNode;
}

void CreateFromLevelInOrder(BiTree &root, vector<DataType> layer, DataType mid[], int midL, int midH)
{
	if (layer.size() == 0) {
		root = NULL; //表示当子树没有左孩子或者右孩子时，leftLayer或者rightLayer为空,将对应的指针域设置为NULL
	}
	else {
		root = NewBiTNode(layer[0]);

		int midIndex = 0;
		for (int i = midL; i <= midH; i++) {
			if (mid[i] == layer[0]) {
				midIndex = i;
				break;
			}
		}

		//分别求出左右子树的层序遍历序列
		vector<DataType>  leftLayer;
		vector<DataType> rightLayer;

		for (int i = 1; i < layer.size(); i++) {
			bool isLeft = false;
			for (int j = midL; j < midIndex; j++) {
				if (mid[j] == layer[i]) {
					isLeft = true;
					break;
				}
			}

			if (isLeft)
				leftLayer.push_back(layer[i]);
			else
				rightLayer.push_back(layer[i]);
		}

		CreateFromLevelInOrder(root->LChild, leftLayer, mid, midL, midIndex - 1);
		CreateFromLevelInOrder(root->RChild, rightLayer, mid, midIndex + 1, midH);
	}
}


//给出二叉树自下到上、从右至左的层次遍历算法
void ReverseLayerOrder(BiTree root, stack<BiTNode*> & reverseLayer)
{
	if (root == NULL) return;

	const int maxn = 30;
	BiTNode * qu[maxn];
	int rear = -1, front = -1;
	qu[++rear] = root;

	BiTNode * p = root;
	while (front < rear ) {//终止条件是队列为空，而不包括p不为NULL， p || 栈不为空 是后序非递归遍历的条件，不要记错了
		p = qu[++front];
		reverseLayer.push(p);
		if (p->LChild)
			qu[++rear] = p->LChild;
		if (p->RChild)
			qu[++rear] = p->RChild;
	}
}

//设计一个非递归算法求二叉树的高度
// 利用层次遍历来计算
typedef struct {
   Elemtype  data[MAXSIZE];
	int rear, front;
}MyQueue;
int TreeHeightNR(BiTree root)
{
	if (!root)
		return 0;
     //设置一个变量来保存当前高度，每次结点出队列放入其子孩子结点其高度要加一
	MyQueue q;
	q.front = q.rear = -1;
	q.data[++q.rear] = root;
	BiTNode * p = NULL;
	int countLayerNodes = 1, layerCount = 0, count ;
	while (q.front < q.rear) {
		int i = 0;
		count = 0;
		while (i < countLayerNodes) {
			p = q.data[++q.front];
			if (p->LChild) {
				q.data[++q.rear] = p->LChild;
				count++;
			}
			if (p->RChild) {
				q.data[++q.rear] = p->RChild;
				count++;
			}
			i++;
		}
		layerCount++;
		countLayerNodes = count;
	}
	return layerCount;
}

//方法2：:层序遍历的同时设置其layer，则最后一个结点的layer为树的高度
typedef struct {
	Elemtype data[MAXSIZE];
	int level[MAXSIZE];
	int rear, front;
}LevelQu;
int TreeHeightNR2(BiTree root)
{
	if (!root) return 0;

	LevelQu qu;
	qu.rear = qu.front = -1;
	BiTNode *p = root;
	int height = 0;
	qu.data[++qu.rear] = root;
	qu.level[qu.rear] = 1;

	while (qu.front < qu.rear) {
		p = qu.data[++qu.front];
		height = qu.level[qu.front];
		if (p->LChild) {
			qu.data[++qu.rear] = p->LChild;
			qu.level[qu.rear] = height + 1;
		}
		if (p->RChild) {
			qu.data[++qu.rear] = p->RChild;
			qu.level[qu.rear] = height + 1;
		}
	}
	return height;
}

//二叉树的路径长度指的是所有结点的路径长度之和
//结点的路径长度等于结点层次减一
int pathLen = 0;
void PathLen(BiTree root, int layer)
{
	if (root != NULL) {
		pathLen += (layer - 1);
		PathLen(root->LChild, layer + 1);
		PathLen(root->RChild, layer + 1);
	}
}

int main()
{
	/*printf("%d\n", CountDigit(123));
	printf("%d\n", CountDigit(12334));*/
	//BiTree root;
	//CreateBiTree(&root);//355 65 9999 7 9999 9999 12666 355 9999 18 9999 9999 1688888888 9999 9999
	//
	//printf("\nPreOrder :\n");
	//preOrder(root);
	//printf("\n");
	//preOrderNR(root);
	//printf("\nInOrder :\n");
	//InOrder(root);
	//printf("\n");
	//InOrderNR(root);
	//printf("\nPostOrder: \n");
	//postOrder(root);
	//printf("\n");
	//postOrderNR(root);

	//printf("\nLayer Order :\n");
	//LayerOrder(root);

	//printf("\nThe 横向打印：\n");
	//HorizontalPrint(root,1);
	//treeHeight2(root, 1);
	//printf("\n The height : %d, %d\n", treeHeight(root), height);

	//CountLeaf2(root);
	//printf("\n The leaf's count is: %d, %d\n", CountLeaf(root), totalLeaf);

	//PrintVertically(root);

	//BiTNode *nearestAncestor = FindCommonAncestor(root, NULL, root->RChild);
	//printf("Ancestor is NULL? %d\n", nearestAncestor == NULL);

	//nearestAncestor = FindCommonAncestor(root, root->RChild->RChild, root->RChild->LChild->RChild);
	//printf("Ancestor is :%d\n", nearestAncestor->data);

	//printf("\nThe number of non leaf is %d\n", CountNoLeaf(root));

	//IsRegularTree(root);
	//printf("1.Tree is reguar tree?%d\n", IsRegular);
	//printf("2.Tree is reguar tree?%d\n", IsRegularTree2(root));
	//printf("3.Tree is reguar tree?%d\n", IsRegularTree3(root));

	//DelXSubTree(root, 355);
	//printf("\n Deleting SubTree of  %d :\n", 355);
	//PrintVertically(root);

	//BiTree root2;
	//printf("Tree2 creating\n");
	//CreateBiTree(&root2);//15 42 9999 9999 36 9999 9999  //90 23 45 9999 9999 9999 32 71 9999 9999 66 78 9999 9999 79 9999 9999
	//PrintVertically(root2);
	//printf("Tree root2 is a complete binary tree? %d\n", IsCompleteTree(root2));
	//printf("The maximum width of root2 is :%d\n", MaxWidth(root2));
	//
	//SwapChildren(root2);
	//PrintVertically(root2);
	//printf("The number of 2 branches node:%d\n", Count2BranchNode(root2));
	//printf("The first node of the post sequence: %d\n", LDRFirstNode(root2)->data);

	//LeafLink(root2);
	//BiTNode * p = head;
	//while (p) {
	//	printf("%d, \n", p->data);
	//	p = p->RChild;
	//}

	//vector<int> postSeq;
	//int seqNum = 0;
	//printf("请输入已知的完全二叉树的先序序列的结点个数：\n");
	//scanf("%d", &seqNum);
	//int * preSeq = new int[seqNum];
	//printf("请输入已知的完全二叉树的先序序列:\n");
	//for (int i = 0; i < seqNum; i++) {
	//	cin >> preSeq[i];
	//}
	//GetPostSeqFromPre(preSeq, 0, seqNum-1, postSeq);
	//printf("后序序列是：\n");
	//for (vector<int>::iterator it = postSeq.begin(); it != postSeq.end(); it++) {
	//	printf("%5d", (*it));
	//}

	//DataType pre[] = { 1,32,45,16, 13, 6 }, mid[] = { 32, 45,1, 13, 16, 6 };
	//BiTree root3;
	//CreateTreePreMid2(root3, pre, 0, 5, mid, 0,5);
	//PrintVertically(root3);

	//DataType post[] = { 45, 32, 13, 6, 16, 1 };
	//BiTree root4;
	//CreateTreeMidPost(root4, mid, 0, 5, post, 0, 5);
	//PrintVertically(root4);

	const int maxn = 40;
	DataType mid[maxn];
	vector<DataType> layer;

	int n;
	scanf("%d", &n);//5
	int temp;
	for (int i = 0; i < n; i++) {
		scanf("%d", &temp);
		layer.push_back(temp); //12 13 14 18 15
	}

	for (int i = 0; i < n; i++) {
		scanf("%d", &temp);
		mid[i] = temp;// 13 18 12 15 14
	}

	BiTree root4;
	CreateFromLevelInOrder(root4, layer,  mid, 0, n-1);
	PrintVertically(root4);
	printf("树高为（使用非递归算法1）:%d\n", TreeHeightNR(root4));
	printf("树高为（使用非递归算法2）:%d\n", TreeHeightNR2(root4));

	stack<BiTNode*>  reverseLayer;
	BiTNode * p = NULL;
	ReverseLayerOrder(root4, reverseLayer);
	while (!reverseLayer.empty()) {
		p = reverseLayer.top();
		printf("%5d", p->data);
		reverseLayer.pop();
	}

	PathLen(root4, 1);
	printf("树的路径长度是：%d\n", pathLen);
}
树的实现--利用二叉链表（孩子-兄弟）存储结构
06-06
C语言树据结构 抽象数据类型的实现—树 利用二叉链表的存储结构，开发工具：VC++
二叉链表存储二叉树
weixin_34032792的博客
08-20 4664
链式存储结构 二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。其结点结构为： 其中，data域存放某结点的数据信息；lchild与rchild分别存放指向左孩子和右孩子的指针，当左孩子或右孩子不存在时，相应指针域值为空（用...
数据结构-二叉链表存储的二叉树
最新发布
qint__的博客
03-24 344
树形结构是一类重要的非线性数据结构，其中以树和二叉树最为常用。对于每一个结点至多只有两课子树的一类树，称其为二叉树。二叉树的链式存储结构是一类重要的数据结构，其形式定义如下：而二叉树的前序、中序遍历是非常重要的能够访问二叉树所有结点的算法，下面分别列出一种先序遍历和两种中序遍历的算法。第一种中序遍历的方法（算法6.3）：第二种中序遍历的方法（算法6.2）：通过读入一个字符串，建立二叉树的算法如下：在本题中，将会给出一个按照先序遍历得出的字符串，空格代表空的子节点，大写字母代表节点内容。
二叉树的二叉链表存储
aeg84268的博客
12-18 319
/* c6-2.h 二叉树的二叉链表存储表示 */ typedef struct BiTNode { TElemType data; struct BiTNode *lchild,*rchild; /* 左右孩子指针 */ }BiTNode,*BiTree; /* bo6-2.c 二叉树的二叉链表存储(存储结构由c6-2.h定义)的基本操作(...
二叉树(链式存储)
wuweixiaoyue的博客
09-22 1663
（1）树是一种非线性的数据结构。（1）判断 root 和 subRoot 是不是两棵相同的树：isSameTree(root,subRoot)（3）判断root左树的子树是不是subRoot：isSubtree(root.right,subRoot)（2）判断root左树的子树是不是subRoot：isSubtree(root.left,subRoot)：若一个结点含有子结点，则这个结点称为其子结点的父结点。：以某结点为根的子树中任一结点都称为该结点的子孙。：一个结点含有的子树的根结点称为该结点的子结点。
用二叉链表存树（孩子兄弟表示法）
17的博客
10-30 9363
用二叉链表的左子树指向该节点最左边的孩子，右子树指向该节点的兄弟，以达到存树的目的
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
首先，二叉链表存储的二叉树是一种通过链表结构来表示二叉树的方式。每个结点包含一个数据元素、一个指向左子结点的指针和一个指向右子结点的指针。在C语言中，可以定义一个结构体类型`BiTNode`来表示这样的结点： ...
二叉链表的应用c++代码_二叉链表c++代码_
09-30
在实际应用中，二叉链表可以用于实现二叉搜索树、AVL树、红黑树等高级数据结构。这些数据结构在搜索、排序、索引等方面表现出色，常用于数据库系统、编译器和操作系统等。 文档“二叉链表的应用c++代码.doc”中可能...
C语言实现二叉链表存储
08-27
C语言实现二叉链表存储 ...C语言实现二叉链表存储是C语言中一种常用的编程技术，它可以用来实现树形结构的存储和遍历。通过对二叉链表存储的实现，我们可以更好地理解C语言的编程技术和数据结构的应用。
二叉链表和顺序表建二叉排序树
07-05
首先，我们来看看如何使用二叉链表作为存储结构来构建二叉排序树。 ##### 数据结构定义 在二叉链表构建的二叉排序树中，每个节点包含三个指针：`leftChild`指向左子树、`rightChild`指向右子树以及`root`指向当前...
二叉链表存储的二叉C语言,C语言实现二叉链表存储
weixin_30725113的博客
05-19 704
利用二叉链表存储，并且利用递归的方法实现二叉树的遍历(前序遍历、中序遍历和后续遍历)操作。c语言具体实现代码如下：#include#include#includetypedef int ElemType;//数据类型//定义二叉树结构，与单链表相似，多了一个右孩子结点typedef struct BiTNode{ElemType data;struct BiTNode *lChild,*rChil...
数据结构课程设计二叉树采用二叉链表作为存储结构
05-01
编写按层次顺序（同一层自左至右）遍历二叉树的算法。 （1）二叉树采用二叉链表作为存储结构。 （2）按题集p44面题6.69所指定的格式输出建立的二叉树。 （3）输出层次遍历结果。 （4）测试用例自己设计。
使用C++链表实现二叉树的存储及基本操作
10-06
使用C++语言，结合单链表的基本操作，实现二叉树的存储，前序、种序、后序遍历及其他基本操作
C++建立二叉链表树
04-20
假设有关二叉树的二叉链表存储的类型定义如下： typedef struct BiTNode{ // 结点结构 ElemType data ；//数据域 struct BiTNode *Lchild ；//左孩子指针 struct BiTNode *Rchild；//右孩子指针 } BiTNode ，*BiTree ；
关于建立二叉链表存储的二叉树：
smile_3229的专栏
10-22 2368
可以采用一级指针和二级指针两种方法： 一级指针
二叉树链式存储
xwy13886467077的博客
09-16 334
上篇我们讲到，完全二叉树采用顺序存储，并讲到其应用堆。这一篇我们来讲讲二叉树的链式存储。二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是 链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所 在的链结点的存储地址。链式结构又分为二叉链和三叉链，当前我们讲解的是二叉链。三叉链会多一个指针指向父亲节点。
二叉树——链式存储
qq_63943454的博客
01-04 1919
上期讲了二叉树的顺序存储，今天来讲一下二叉树的链式存储。
二叉树的二叉链表存储及基本操作
Junds0的博客
05-18 5265
第1关：先序遍历创建二叉链表存储的二叉树及遍历操作 本关任务：以二叉链表作存储结构存储二叉树，利用先序递归遍历创建二叉树，并依次进行二叉树的前序、中序、后序递归遍历。 #include <stdio.h> #include <stdlib.h> #include "bitree.h" TElemType Nil='#'; void visit(TElemType s) { printf("%c,",s); } void input(TEl
二叉链表存储的二叉树
欢迎访问我的个人Blog网站：blog.homeryland.org
06-07 1681
在本题中，将会给出一个按照先序遍历得出的字符串，空格代表空的子节点，大写字母代表节点内容。请通过这个字符串建立二叉树，并按照题目描述中的先序遍历，中序遍历，后序遍历的算法分别输出每一个非空节点。保证S为合法的二叉树先序遍历字符串，节点内容只有大写字母，且S的长度不超过100。而二叉树的前序、中序遍历是非常重要的能够访问二叉树所有结点的算法，下面分别列出一种先序遍历，一种中序和一种后序遍历的算法。共有三行，每一行包含一串字符，表示分别按先序、中序、中序得出的节点内容，每个字母后输出一个空格。
二叉树可以用二叉链表存储，树无法用二叉链表存储。
05-16
实际上，树也可以用二叉链表进行存储。在二叉链表存储结构中，每个节点除了有指向左右子节点的指针外，还可以有指向兄弟节点的指针。因此，我们可以将树转化为二叉树进行存储，具体的方法是将每个节点的第一个子节点作为它的左子节点，将它的其他子节点作为它的左子节点的兄弟节点。 这种方法可以使树的遍历算法与二叉树的遍历算法相同，因为树的前序遍历、中序遍历和后序遍历等算法都可以通过二叉树的前序遍历、中序遍历和后序遍历算法来实现。因此，树的数据结构可以使用二叉链表来进行存储，这种存储方式被称为“树的孩子-兄弟表示法”。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值