二叉树的相关算法

最新推荐文章于 2024-07-08 22:12:26 发布
最新推荐文章于 2024-07-08 22:12:26 发布
阅读量1.2k 收藏 26
点赞数 2
分类专栏： 笔记 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/threestooegs/article/details/121114389
版权

0、二叉树的结点表示

if(p->lchild != NULL && p->rchild != NULL)//度为2的结点，左右孩子同时不空
if((p->lchild == NULL && p->rchild != NULL) || (p->lchild != NULL && p->rchild == NULL))//度为1的结点，左孩子不为空，或者右孩子不为空
if(p->lchild == NULL && p->rchild == NULL)//度为0的结点，两个孩子都为空

1、二叉树的先序遍历递归与非递归

void preorder(BiTree T)
{
		if(T != NULL)
		{
				visit();
				preorder(T->lchild);
				preorder(T->rchild);
		}
}
//一直入栈往左走，到头出栈掉个头
void preorder(BiTree T)
{
		InitStack(S);
		p = T:
		while(p != NULL || !StackEmpty(S))
		{
					if(p !=NULL)
					{
								printf(p->data);
								push(S,p);
								p = p->lchild;
					}
					else
					{
								pop(S,p);
								p = p->rchild;
					}
		}
}

2、二叉树的中序遍历

void Inorder(BiTree T)
{
		if( T != NULL)
		{
					Inorder(T->lchild);
					visit(T);
					Inorder(T->rchild);
		}
}
void Inorder(BiTree T)
{
		InitStack(S);
		p = T;
		while(p != NILL || !StackEmpty(S))
		{
					if(p != NULL)
					{
							push(S,p);
							p = p->lchild;		
					}
					else
					{
								pop(S,p);
								printf(p->data);
								p = p->rchild;
					}
		}
}

3、二叉树的后序遍历

void postorder(BiTree T)
{
		if(T != NULL)
		{
					postOrder(T->lchild);
					postorder(T->rchild);
					visit(T);
		}
}
void PostOrder(BiTree T)
{
		InitStack(T);
		p = T;
		while(p != NULL || !StackEmpty(s))
		{
				if(p != NULL)
				{
							push(S,p);
							p = p->lchild;
				}
				else
				{
							pop(S,p);
							if(p->rchild == NULL && (p->rchild).tag == 0)//如果右孩子为空或者标志位为0则
							{
										push(S,p);
										p = p->rchild;
							}
							else//如果top的右孩子为空且没有被访问过则输出
							{
										printf(p->data);
										p.tag = 1;
										p = NULL;
							}
				}
		}
}

4、二叉树的层序遍历算法

void LevelOrder(BiTree T)
{
		InitQueue(Q);
		BiTree p;
		EnQueue(Q,T);
		while(!IsEmpty(Q))
		{
				DeQueue(Q,p);
				visit(p);
				if(p->lchild != NULL)
						EnQueue(Q,p->lchild);
				if(p->rchild != NULL)
						EnQueue(Q,p->rchild);
		}
}

void levelorder(BiTree T)
{
		BiTree Q[MAXSIZE];
		BiTree p = T;
		int front = -1,rear = -1;
		int last = 0,level = 0;
	
		Q[++rear] = T;
		while(front < rear)//队列不为空
		{
				p = Q[++front];
				if(p->lchild)
						Q[++rear] = p->lchild;
				if(p->rchild)
						Q[++rear] = p->rchild;
		}
}

5、编写二叉树自下而上，从右到左的层序遍历算法
算法思想
一般的二叉树层序遍历是自上而下，从左到右的顺序，可以将每一次访问的结点入栈，遍历结束后在出栈

void LevelOrder(BiTree T)
{
		InitQueue(Q);
		InitStack(S);
		BiTree p = T;
		EnQueue(Q,p);
		while(!isEmpty(Q))
		{
					DeQueue(Q,p);
					posh(S,p);
					if(p->lchild != NULL)
					{
								Enqueue(Q,p->lchild);
					}
					if(p->rchild != NULL)
					{
								Enqueue(Q,p->rchild)
					}
		}
		while(IsEmpty(s))
		{
					pop(S,p);
					visit(p->data);
		}
}

6、求二叉树中层序的最高度

int Bidepth(BiTree T)
{
		if(T == NULL)
		{
				return 0;
		}
		else
		{
				BiTree Q[Maxsize];
				BiTree p;
				int front = -1,rear = -1;
				int last = 0,level = 0;

				Q[++rear] = T;
				while(front < rear)
				{
						p = Q[++front];
						if(p->lchild != NULL)
								Q[++rear] = p->lchild;
						if(p->rchild != NULL)
								Q[++rear] = p->rchild;
						if(front == level)
						{
									level++;
									last = rear;//last指向当前层数的最右结点，这个地方不是很理解，硬记！
						}
			}
		}
}

7、求二叉树中宽度

int Width(BiTree T)
{
		if(T == NULL)
		{
					return 0;
		}
		else
		{
					BiTree Q[MAXSIZE];
					BiTree p;
					int front = -1,rear = -1;
					int last = 0,count = 0;
	
					Q[++rear] = T;
					while(front < rear)
					{
							p = Q[++front];
							temp++;
							if(p->lchild != NULL)
									Q[++rear] = p->lchild;
							if(p->rchild != NULL)
									Q[++rear] = p->rchild;
							if(front > last)//不是很理解为啥
							{
										last = rear;//为沙
										if(temp > maxw)
												maxw = temp;
										temp = 0;
							}
					}
		}
		return maxw;
}

8、计算二叉树所有结点个数

int Node(BiTree T)
{
		int num1,num2;
		if(T == NULL)
				return 0;
		else
		{
				num1 = Node(T->lchild);
				num2 = Node(T->rchild);
				return (num1 + num2 + 1);//因为有根结点所有要+1
		}
}

9、计算二叉树所有的叶子结点（度为1的结点）

int Node(BiTree T)
{
		if(T == NULL)
				return 0;
		else if(T->lchild == NULL && T->rchild == NULL)
				return 1;
		else
		{
				num1 = Node(T->lchild);
				num2 = Node(T->rchild);
				return num1+num2;
		}
}

10、计算二叉树中双分支结点（度为2的结点）

int Node(BiTree T)
{
		if(T == NULL)
				return 0;
		else if(T->lchild == NULL || T->rchild == NULL)//当n为单分支时不计算
				n = 0;
		else//当为双分支时n=1
				n = 1;
		num1 = Node(T->lchild);
		num2 = Node(T->rchild);
		return (num1+num2+n)
}
int

11、求二叉树中最小值的结点

int FindMinNode(BiTree T)
{
		if(T != NULL)
		{
				if(T->data < min)
				{
							min = T->data;
				}
				FindMinNode(T->lchild,min);
				FindMinNode(T->rchild,min);
		}
}

int preorder(BiTree T)
{
		min = 0
		if(T != NULL)
		{
				if(min > T->data)
						min = T->data;
				preorder(T->lchild);
				preorder(T->rchild);
		}
		return min;
}

12、求二叉树所有结点值的和

int Findsum(BiTree T)
{
		if(T == NULL)
				return 0;
		else
				return (T->data + Findsum(T->lchild) + Findsum(T->rchild));

}
int preorder(BiTree T)
{
		int sum = 0
		if(T != NULL)
		{
				sum += T->data;
				preorder(T->lchild);
				preorder(T->rchild);
		}
		return sum;
}

13、求二叉树中值为x的结点

int FindCount(BiTree T,int x)
{
			count = 0;
			if(T != NULL)
			{
					if(T->data == x)
							count++;
					FindCount(T->lchild);
					FindCount(T->rchild);
			}
			return count;
}
int FindCount(BiTree T,int x)
{
		if(T == NULL)
				return 0;
		else if(T->data == x)
				return (1+FindCount(T->lchild,x) + FindCount(T->rchild,x));
		else
				return (FindCount(T->lchild,x) + FindCount(T->rchild,x));
}

14、求二叉树结点的高度

int Depth(BTNode *T)
{
		if(T == NULL)
				return 0;
		else
		{
				ldeep = Depth(T->lchild);
				rdeep = Depth(T->rchild);
				return (ldeep > rdeep):(ldeep + 1):(rdeep + 1);//加1是因为根结点
		}
}

15、求指定值x的双亲结点p(没看懂)
算法思想
在二叉树中查找x的双亲结点，找到后p指向x结点的双亲结点否则p=NULL，当b为空或根结点为x时，p=NULL

void FindParent(BiTree T,int x,BiTree &p)
{
		if(T != NULL)
		{
				if(T->data == x)
				{
						p = NULL;
				}
				else if(T->lchild != NULL && T->lchild->data == x)//如果T->lchild 不为空或者T->lchild==x则
				{
						p = b;
				}
				else if(T->rchild != NULL && T->rchild->data == x)
				{
						p = b;
				}
				else
				{
							FindParent(T->lchild,x,p);
							if(p == NULL)
									FIndParent(T->rchild,x,p);
				}
		}
		else
		{
				p = NULL;
		}
}

16、交换树b的左右子树

void Swap(BiTree T)
{
		BiTree *Temp;
		if(T != NULL)
		{
				Swap(T->lchild);
				Swap(T->rchild);
				temp = T->lchild;
				T->lchild = T->rchild;
				T->rchild = temp;
		}
}

17、求二叉树T中值为x的层号

int level(BiTree T)
{
		InitQueue(Q);
		P = T;
		Enqueue(Q,p);
		while(!IsEmpty(Q))
		{
				DeQueue(Q,p);
				visit(p);
				if(p->lchild != NULL)
						Enqueue(Q,p->lchild);
				if(p->rchild != NULL)
						Enqueue(Q,p->rchild);
		}
}
int level(BiTree T)
{
		if(T == NULL)
		{
					return 0;
		}
		else
		{
				BiTree Q[MAXSIZE];
				BiTree p;
				int front = -1,rear = -1;
				int last = 0,level = 0;
		
				Q[++rear] = T;
				while(front < rear)
				{			
							p = Q[++front];
							if(p->data == x)
									return level;
							if(p->lchild != NULL)
							{
										Q[++rear] = p->lchild;
							}
							if(p->rchild != NULL)
							{
										Q[++rear] = p->rchild;							
							}
							if(front == level)
							{
										level++;
										last = rear;
							}
				}
		}
}
int NodeLevel(BiTree T,int x,int h)
{
		int h1;
		if(T == NULL)
				return 0;
		else if(T->data == x)
				return h;
		else
		{
				h1 = NodeLevel(T->lchild,x,h+1);//在左子树中递归查找
				if(h1 == 0)//为沙呀，没看懂
						return NodeLevel(T->rchild,x,h+1);//左子树中为找到在右子树查找
				else
						return h1;
		}
}

18、求先序遍历中第k个结点的值
算法思想
用全局变量n保存先序遍历时访问结点，
当二叉树为空时返回空，
当k==n时表示找到结点，
当k！=n时，在左子树找，若找到返回，否则在右子树找，返回

int preorder(BiTree T,int k)
{	
		int count = 0;
		p = T;
		if(p != NULL)
		{
				if(k == count)
						visit(p->data);
				count++;
				preorder(p->lchild);
				preorder(p->rchild);
		}
}
int preNode(BiTree T,int k)
{
		if(T == NULL)
				return 0;
		if(n == k)
				return T->data;
		n++;
		ch = PreNode(T->lchild,k);
		if(ch != NULL)
				return ch;
		ch = PreNode(T->rchild,k);
				return ch;
}

19、中序遍历中第k的结点

ElemType InNOde(BiTree T,int k)
{
		if(T == NULL)
		{
				return 0;
		}
		ch = InNode(T->lchild);//在左子树中找
		if(ch != NULL)//找到返回
				return ch;
		else//在右子树找
		{
				if(n == k)
						return T->data;
				n++;
				return InNode(T->rchild,k);
		}

}

20、后序遍历中第k的结点

ElemType PostNode(BiTree T,int k)
{
		if(T == NULL)
				return 0;
		ch = postnode(T->lchild,k);
		if(ch != NULL)
				return ch;
		else
		{
				ch = postNode(T->rchild,k);
				if(ch != NULL)
						return ch;
				if(n == k)
						return T->data;
				n++;
		}
}

21、求二叉树的WPL
算法思想
基于先序遍历，记录每个wpl把每个结点的深度作为递归函数的一个参数

int wpl_preorder(BiTree T,int deep)
{
		int wpl = 0;
		if(T->lchild == NULL && T->rchild == NULL)//叶子结点，度为0的结点计算wpl
				wpl = wpl + deep*T->weight;
		if(T->lchild != NULL)
				wpl_preorder(T->lchild,deep+1);
		if(T->rchild != NULL)
				wpl_preorder(T->lchild,deep+1);
		return wpl;
}

22、将二叉树转为中缀表达式，通过括号反映出优先级次序
算法思想
如果是叶子结点输出，除根结点外，遍历左子树之前加左括号，遍历完右子树加右括号

typedef struct Node
{
		char data[10];
		struct node *left,*right;
}BiTree;
void BtreeToExp(BiTree T,int deep)
{
		if(T == NULL)
				return 0;
		else if(T->left === NULL && T->right == NULL)//如果是叶子结点则输出
				print(T->data);
		else
		{
				if(deep > 1)	//若有子表达式，则加括号	
					printf("(");
				BtreeToExp(T->left,deep+1);
				printf(T->data);
				BtreeToExp(T->right,deep+1);
				if(deep > 1)//加括号
					printf(")");
		}
}

23、输出从根到叶子结点的路径

int path(BiTree *p)
{
		int i = 0,top = 0;
		ElemType stack[MAXSIZE];
		if(p != NULL)
		{
				stack[++top] = p->data;
		}
		if(p->lchild == NULL && p->rchild == NULL)
		{
				for(i = 0;i < top;i++)
				{
						printf(stack[i]);
				}
		}
		path(p->lchild);
		path(p->rchild);
		--top;
}

24、判断二叉树是否为完全二叉树
算法思想
如果树为空，则直接返回错。
如果树不为空，层次遍历二叉树 ；
如果树左孩子为空，右孩子不为空，则该树一定不是完全二叉树；
如果树左右孩子都不为空，则pop该节点，将其左右孩子入队列；
如果树左孩子不为空，右孩子为空；或者左右孩子都为空；则该节点之后的队列中的结点都为叶子节点；
该树才是完全二叉树，否则就不是完全二叉树。

void level(BiTree T)
{
		InitQueue(Q);
		EnQueue(Q,T);
		if(T == NULL)
				return 0;
		while(!isempty(Q))
		{
				if(T->lchild == NULL && T->rchild != NULL)//如果左子树为空，右子树不为空则肯定不是完全二叉树
						return 0;
				if(T->lchild != NULL && T->rchild != NULL)//如果左右孩子都不为空
				{
						DeQueue(Q,T);
						EnQueue(Q,T->lchild);
						EnQueue(Q,T->rchild);
				}
				if((T->lchild != NULL && T->rchild == NULL) || T->lchild == NULL && T->rchild != NULL)//为叶子结点
				{
						DeQueue(Q,T);
						while(QueueLength(Q))
						{
								if(T->lchild == NULL && T->rchild == NULL)
								{
											DeQueue(Q,t);
								}
								else
								{
											return 0;
								}
								return 1;
						}
				}
				
				//DeQueue(Q,p);
				//if(p->lchild != NULL)
				//		EnQueue(Q,p->lchild);
				//if(p->rchild != NULL)
				//		EnQueue(Q,p->rchild);
		}
		return 1;
}
李昂的
关注
  • 2
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
二叉树相关算法
liyidaozhang的博客
06-04 243
二叉树Path Sum判断二叉树是否有一条path，路径和等于sum递归遍历二叉树，每到一个节点判断是否是叶子节点，是叶子节点再判断路径和是否和sum相等。路径和由compare函数的result参数传入。方法每次进入java栈前将此节点的val值传给result参数。/** * Definition for a binary tree node. * public class TreeNode
求结点x在二叉树中的双亲结点算法
qq_46504622的博客
12-26 1821
#include <stdio.h> #include <stdlib.h> #define N 50 //2020真题 struct student { char name[20]; float score[5]; double average,weighted_average; }stu[N],temp; int main() { int a,b,c,d,e; void sort(struct student s[]); struct student *p = s
求一个结点x在在二叉树中的双亲结点算法
qq_51691366的博客
10-18 6795
该算法的实现是借助二叉树的先序遍历。递归遍历二叉树，每一次递归调用首先利用先序遍历判断当前根节点是否存在左右孩子，若是存在并且左右中的数值就是所给参数的孩子结点，那么当前父节点肯定是所给孩子结点的父亲节点，直接使用return返回当前参数结点的父亲节点，强行退出递归调用栈，程序执行完毕！否则继续递归调用二叉树，直到查找成功或者失败！使用先序递归遍历思想完成算法设计。首先判断节点的左右孩子是否存在，若存在，并且左右孩子中有一个符合查找要求，则返回元素！否则，继续递归查找，直到成功或者找不到符合要求的结点！
设计一个求结点x在二叉树中的双亲结点算法
qq_53943186的博客
08-22 2459
如果 x 不是根节点，检查根节点的左子树和右子树是否存在 x 节点。若左子树中找到了 x 节点，则返回根节点作为 x 的双亲节点。首先检查根节点是否为空或者根节点是否就是要查找的节点 x，若是，则说明 x 没有双亲节点，返回空（或者其他适合的标识）。否则，在右子树中找到了 x 节点，则同样返回根节点作为 x 的双亲节点。是要查找其双亲节点的节点。是当前子树的根节点，
求结点x在二叉树中的双亲结点
小太阳晨曦
09-08 1308
求结点x在二叉树中的双亲结点
【数据结构】设一棵树T，用二叉链表表示。编写函数，给定树中结点p，求p的双亲结点
每天进步一点丶的博客
03-15 605
1.算法思想 使用层序遍历+队列实现该功能。 孩子兄弟表示法能够有效的知道某个结点的所有孩子，因此使用层序遍历时： 获取队头结点，将该结点的所有孩子都入队。入队时判断是否为目标结点，如果是则返回该队头结点，否则将该队头结点处理完后继续处理该队头结点的兄弟结点，方法与前面一致。 2.定义结构体 使用二叉链表(孩子兄弟表示法)存储树的结构。 typedef struct BiNode { char data; struct BiNode *firstChild; struct BiNod
二叉树相关算法.rar
09-22
下面我们将详细探讨八种可能的二叉树算法，以及如何非递归地解决它们。 1. **遍历**：二叉树的遍历分为前序遍历、中序遍历和后序遍历。非递归实现通常采用栈来完成。例如，前序遍历（根-左-右）可以先将根节点压...
二叉树相关算法的具体实现
07-14
本文件包含前序和层序创建二叉树，前序、中序、后序遍历二叉树的递归和非递归版本，以及层序遍历。
二叉树遍历算法
08-04
二叉树遍历算法是计算机科学中的一种基本数据结构操作，尤其在处理树形数据结构时至关重要。二叉树是一种每个节点最多有两个子节点（通常称为左子节点和右子节点）的数据结构，广泛应用于搜索、排序、编译器设计等...
考研常考的二叉树相关算法总结（详细全面，PDF版）
11-16
主要针对考研常考的二叉树相关算法，包括但不限于对普通二叉树的构造、查找、插入元素、（先序、中序、后序、层序）遍历，并含递归和非递归方式等的算法、求二叉树的深度、删除二叉树中以某个结点为根结点的子树、...
二叉树实现以及相关算法
04-09
cout****** 二叉树二叉链表结构测试程序 ******"; cout* 0--退出 *"; cout* 1--交互创建二叉树 *"; cout* 2--文件创建二叉树 *"; cout* 3--完全二叉树序列创建二叉树 *"; cout* 4--打印二叉树 *"; cout* 5--...
求二叉树中结点x的双亲结点
vener_的博客
09-24 1万+
typedef struct BiTNode { ElemType data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; BiTNode *parent(BiTree T,ElemType x) { BiTNode *ans; if(T==NULL) return NULL; if(T->lchild==NULL&&T->rchild==NULL) return NULL else { if.
求一个结点x在二叉树中的双亲结点
qq_63378602的博客
12-05 679
二叉树、求一个结点x在二叉树中的双亲结点
C++查找二叉树中指定值的双亲节点
jmxyqrx的博客
11-17 2440
这里写自定义目录标题题目与思路代码 题目与思路 题目：假设二叉树中所有结点值为单个字符且均不相同，采用二叉链存储结构存储。设计一个算法求二叉树b中指定值为x的结点的双亲节点p，提示：根节点的双亲节点为NULL，若在b中未找到值为x的结点，p也为NULL；并用相关数据进行测试。 思路：在创建二叉树时直接将各个节点的parent节点保存起来。 代码 去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片. #include <iostream> using namespace s
设计一个求结点x在二叉树中的双亲结点的算法（C语言版）
m0_75063536的博客
11-26 385
printf("节点 %d 的双亲节点是 %d\n", targetNode, parent->data);printf("未找到节点 %d 的双亲节点\n", targetNode);// 如果根节点就是目标节点，返回 NULL，因为根节点没有双亲节点。// 如果目标节点是根节点的左子节点或右子节点，返回根节点。// 如果左右子树都没有找到，返回 NULL。// 在二叉树中查找指定节点的双亲节点。// 递归在左子树中查找。// 递归在右子树中查找。// 二叉树节点结构。
求二叉树的双亲结点
热门推荐
qq_43650421的博客
07-08 1万+
思路就是如果当前任一个孩子结点的值等于k，说明当前节点即为所需结点的双亲结点，通过递归实现唯一比较麻烦的是要写很多条件，不然会报错。 主要功能实现是preorder函数其他是构建和打印二叉树的函数。 #include<stdio.h> #include<vector> #include<queue> using namespace std; #define Type char //要求1.二叉树中的结点个数2.叶子结点个数3.某结点层次4.二叉树的宽度 struct
【代码随想录_Day27】509 斐波那契数 70 爬楼梯 746 使用最小花费爬楼梯
最新发布
qq_43671872的博客
07-08 626
509 斐波那契数70 爬楼梯746 使用最小花费爬楼梯今天的题目难度不低，尽量还是写一些简洁代码 ^ _ ^
二叉树遍历算法课程设计
10-25
二叉树遍历算法是计算机科学中的一个重要主题，它是指按照某种顺序遍历二叉树中的所有节点。常见的二叉树遍历算法有三种：前序遍历、中序遍历和后序遍历。 前序遍历是指先访问根节点，然后按照左子树、右子树的顺序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值