数据结构之树和二叉树

最新推荐文章于 2024-09-27 14:59:03 发布
最新推荐文章于 2024-09-27 14:59:03 发布
阅读量244 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 二叉树 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44161383/article/details/103627866
版权

十一，实现二叉树的各种基本运算的方法

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#define ElemType char
#define max 100
typedef struct node
{
	ElemType data;
	struct node *lchild;  //左孩子 
	struct node *rchild;  //右孩子 
}BTNode;

void CreateTree(BTNode *&b, char *str)		//创建二叉树 
{
	BTNode *st[max];	//st数组作为顺序栈	
	BTNode *p;
	int top = -1, k, j = 0;
	char ch;
	b = NULL;
	ch = str[j];
	while (ch != '\0')
	{
		switch (ch)
		{
			case '(':top++; st[top] = p; k = 1; break;
			case ')':top--; break;
			case ',':k = 2; break;
			default:
			{
					   p = (BTNode *)malloc(sizeof(BTNode));
					   p->data = ch;
					   p->lchild = NULL; p->rchild = NULL;
					   if (b == NULL)
						   b = p;
					   else
					   {
						   switch (k)
						   {
						   case 1:st[top]->lchild = p; break;
						   case 2:st[top]->rchild = p; break;
						   }
					   }
			}
				
		}
		j++;
		ch = str[j];
	}
}

void destorytree(BTNode *&b)			//销毁二叉树 
{
	if (b != NULL)
	{
		destorytree(b->lchild);
		destorytree(b->rchild);
		free(b);
		b = NULL;
	}
	//ClearBiTree();
}
 void ClearBiTree(BTNode *T)			//清空 
{
    if(T == NULL)
        return;
    ClearBiTree(T->lchild);
    ClearBiTree(T->rchild);
    free(T);
}
BTNode *findnode(BTNode *b, ElemType e)			//查找结点 
{
	BTNode *p;
	if (b == NULL)
		return 0;
	else if (b->data == e)
		return b;
	else
	{
		p = findnode(b->lchild, e);
		if (p != NULL)
		{
			return p;
		}
		else
			return findnode(b->rchild, e);

	}
}

BTNode *Lchildnode(BTNode *p)		//找左孩子节点 
{
	return p->lchild;
}
BTNode *Rchildnode(BTNode *p)		//找右孩子节点 
{
	return p->rchild;
}


int height(BTNode *b)	        	//求高度 
{
	int lh, rh;
	if (b == NULL)
		return 0;
	else
	{
		lh = height(b->lchild);
		rh = height(b->rchild);
		return(lh>rh) ? (lh+1 ): (rh+1);
	}
}

void disptree(BTNode *b)
{
	if (b != NULL)
	{
		printf("%c", b->data);
		if (b->lchild != NULL || b->rchild != NULL)
		{
			printf("(");
			disptree(b->lchild);
			if (b->rchild != NULL)
				printf(",");
			disptree(b->rchild);
			printf(")");
			
		}
	}

}
int main()
{
	char c[100] = "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";
	BTNode *b,*x,*y;
	CreateTree(b, c);
	printf("输出二叉树为：\n");
	disptree(b);
	printf("\n\nH的左节点为：\n");
	x=Lchildnode(findnode(b,'H'));
	disptree(x);
	printf("\n\n右节点为:\n");
	y=Rchildnode(findnode(b,'H'));
	disptree(y);
	printf("\n\n二叉树的高度为：%d",height(b));
	printf("\n");
	destorytree(b);ClearBiTree(b);
	if(b==NULL)
		printf("释放成功\n");
	system("pause");		
	return 0;
}

在这里插入图片描述

十二，实现二叉树的各种遍历算法

在这里插入图片描述

#include<stdio.h>
#include<stdlib.h>
#define ElemType char
#define max 100
typedef struct node
{
	ElemType data;
	struct node *lchild;  //左孩子 
	struct node *rchild;  //右孩子 
}BTNode;
typedef struct
{
	BTNode * data[max];
	int front, rear;
}SqQueue;

void CreateTree(BTNode *&b, char *str)		//创建二叉树 
{
	BTNode *st[max];	//st数组作为顺序栈
		BTNode *p;
	int top = -1, k, j = 0;
	char ch;
	b = NULL;
	ch = str[j];
	while (ch != '\0')
	{
		switch (ch)
		{
		case '(':top++; st[top] = p; k = 1; break;
		case ')':top--; break;
		case ',':k = 2; break;
		default:
		{
				   p = (BTNode *)malloc(sizeof(BTNode));
				   p->data = ch;
				   p->lchild = NULL; p->rchild = NULL;
				   if (b == NULL)
					   b = p;
				   else
				   {
					   switch (k)
					   {
					   case 1:st[top]->lchild = p; break;
					   case 2:st[top]->rchild = p; break;
					   }
				   }
		}

		}
		j++;
		ch = str[j];
	}
}


void destorytree(BTNode *&b)			//销毁二叉树 
{
	if (b != NULL)
	{
		destorytree(b->lchild);
		destorytree(b->rchild);
		free(b);
		b = NULL;
	}
	//ClearBiTree();
}
void ClearBiTree(BTNode *T)			//清空二叉树 
{
	if (T == NULL)
		return;
	ClearBiTree(T->lchild);
	ClearBiTree(T->rchild);
	free(T);
}

void disptree(BTNode *b)		//输出二叉树 
{
	if (b != NULL)
	{
		printf("%c", b->data);
		if (b->lchild != NULL || b->rchild != NULL)
		{
			printf("(");
			disptree(b->lchild);
			if (b->rchild != NULL)
				printf(",");
			disptree(b->rchild);
			printf(")");

		}
	}

}

void Preorder(BTNode *b)      //先序遍历递归算法(跟   左  右)
{
	if (b != NULL)
	{
		printf("%4c", b->data);
		Preorder(b->lchild);
		Preorder(b->rchild);
	}
}
void Inorder(BTNode *b)      //中序遍历递归算法(左  跟   右)
{
	if (b != NULL)
	{
		Inorder(b->lchild);
		printf("%4c", b->data);
		Inorder(b->rchild);
	}
}
void Postorder(BTNode *b)      //后序遍历递归算法(左  右   跟)
{
	if (b != NULL)
	{

		Postorder(b->lchild);
		Postorder(b->rchild);
		printf("%4c", b->data);
	}
}
void InitQueue(SqQueue *&q)
{
	q = (SqQueue *)malloc(sizeof(SqQueue));
	q->front = q->rear = 0;
}
void DestroyQueue(SqQueue *&q)
{
	free(q);
}
bool emptyQueue(SqQueue *q)
{
	return(q->front == q->rear);
}
//进队列
bool enQueue(SqQueue * &q,BTNode * &b)
{
	if(q->rear==max-1)
	{				
		return false;					
	}
	q->rear++;							
	q->data[q->rear]=b;				
	return true;							
}

//出队列 
bool deQueue(SqQueue * &q,BTNode * &b)
{
	if(q->front==q->rear)
	{				 
		return false;					
	}
	q->front++;							
	b=q->data[q->front];			
	return true;					
}


void levelOrder(BTNode * &b)		//层次遍历 
{
	SqQueue *q;								
	InitQueue(q);							
	if(b!=NULL)
	{
		enQueue(q,b);						
	} 
	while(emptyQueue(q)!=true)
	{				
		deQueue(q,b);						
		printf("%4c",b->data);				
		if(b->lchild!=NULL)
		{				
			enQueue(q,b->lchild);
		}
		if(b->rchild!=NULL)
		{				
			enQueue(q,b->rchild);
		}									
	} 											
}



int main()
{
	int n;
	char c[100] = "A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))";
	BTNode *b;
	CreateTree(b, c);
	printf("输出二叉树为：\n");
	disptree(b);
	printf("\n输入你要进行的操作\n1.    先序排列\n2.    中序排列\n3.    后序排列\n4.    层次排列\n");
	while (scanf("%d", &n))
	{

		switch (n)
		{
		case 1:
			Preorder(b);
			printf("\n");
			break;
		case 2:
			Inorder(b);	printf("\n");
			break;

		case 3:
			Postorder(b); printf("\n");
			break;
		case 4:levelOrder(b); printf("\n");
			break;

		}
	}
	destorytree(b); ClearBiTree(b);
	if (b == NULL)
		printf("释放成功\n");
	system("pause");
	return 0;
}

在这里插入图片描述

十三，由遍历序列构造二叉树

在这里插入图片描述

#include<stdio.h> 
#include<stdlib.h>
#define ElemType char
#define max 100
typedef struct node
{
	ElemType data;
	struct node *lchild;  //左孩子 
	struct node *rchild;  //右孩子 
}BTNode;

void CreateTree(BTNode *&b, char *str)		//创建二叉树 
{
	BTNode *st[max];	//st数组作为顺序栈	
	BTNode *p;
	int top = -1, k, j = 0;
	char ch;
	b = NULL;
	ch = str[j];
	while (ch != '\0')
	{
		switch (ch)
		{
			case '(':top++; st[top] = p; k = 1; break;
			case ')':top--; break;
			case ',':k = 2; break;
			default:
			{
					   p = (BTNode *)malloc(sizeof(BTNode));
					   p->data = ch;
					   p->lchild = NULL; p->rchild = NULL;
					   if (b == NULL)
						   b = p;
					   else
					   {
						   switch (k)
						   {
						   case 1:st[top]->lchild = p; break;
						   case 2:st[top]->rchild = p; break;
						   }
					   }
			}
				
		}
		j++;
		ch = str[j];
	}
}


void destorytree(BTNode *&b)			//销毁二叉树 
{
	if (b != NULL)
	{
		destorytree(b->lchild);
		destorytree(b->rchild);
		free(b);
		b = NULL;
	}
	//ClearBiTree();
}
 void ClearBiTree(BTNode *T)			//清空二叉树 
{
    if(T == NULL)
        return;
    ClearBiTree(T->lchild);
    ClearBiTree(T->rchild);
    free(T);
}

void disptree(BTNode *b)		//输出二叉树 
{
	if (b != NULL)
	{
		printf("%c", b->data);
		if (b->lchild != NULL || b->rchild != NULL)
		{
			printf("(");
			disptree(b->lchild);
			if (b->rchild != NULL)
				printf(",");
			disptree(b->rchild);
			printf(")");
		}
	}

}

BTNode *CreateBT1(char *pre,char *in,int n)   		//先序和中序
{
	BTNode *b;
	char *p;
	int k;
	if(n<=0)
	return NULL;
	b=(BTNode *)malloc(sizeof(BTNode));
	b->data=*pre;
	for(p=in;p<in+n;p++)
	{
		if(*p==*pre)
			break;
	}
		k=p-in;
		b->lchild=CreateBT1(pre+1,in,k);
		b->rchild=CreateBT1(pre+k+1,p+1,n-k-1);
		return b;
	
}
BTNode * CreateBT2( char * post, char * in, int n )
{
	BTNode	* b;
	char	r, *p;
	int	k;
	if ( n <= 0 )
		return(NULL);
	r	= *(post + n - 1);
	b	= (BTNode *) malloc( sizeof(BTNode) );
	b->data = r;
	for ( p = in; p < in + n; p++ )
		if ( *p == r )
			break;
	k		= p - in;
	b->lchild	= CreateBT2( post, in, k );
	b->rchild	= CreateBT2( post + k, p + 1, n - k - 1 );
	return(b);
}

int main()
{
	int n;
	char c1[100]="ABDEHJKLMNCFGI";
	char c2[100]="DBJHLKMNEAFCGI";
	char c3[100]="DJLNMKHEBFIGCA";
	BTNode *b;
	BTNode *x;
	
	printf("\n输入你要进行的操作\n1.   先序和中序输出\n2.   中序和后序输出\n");
	while(scanf("%d",&n))
	{
		switch(n)
		{
			case 1:	
					b=CreateBT1(c1,c2,14);
					printf("先序为：%s\n",c1);
					printf("中序为：%s\n",c2);
					printf("输出二叉树为：\n");
					disptree(b);
					printf("\n");
					break;
			case 2:
					{
		
					printf("中序为：%s\n",c2);
					printf("后序为：%s\n",c3);
					x=CreateBT2(c3,c2,14);
					printf("输出二叉树为：\n");
					disptree(x);
					printf("\n");
					break;
				}
		
		}
	}
	destorytree(b);ClearBiTree(b);
	if(b==NULL)
		printf("释放成功\n");
	system("pause");
	return 0;
}

在这里插入图片描述

十四，构造哈夫曼树和生成哈夫曼编码

在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N (50)      // 树中叶子结点数最大值
#define M (2 * N - 1) // 树中结点总数最大值

typedef struct
{
	   char data[5]; // 结点值
	   int weight; // 权重
	   int parent; // 双亲结点
	   int lchild; // 左孩子结点
	   int rchild; // 右孩子结点
}HTNode; // 声明哈夫曼树结点类型

typedef struct
{
	   char cd[N]; // 存放哈夫曼编码
	   int start;
}HCode; // 声明哈夫曼编码类型

/*-------------由含有n个叶子结点的ht构造完整的哈夫曼树-----------------*/
void create_huffman_tree(HTNode ht[], int n)
{
	   int i;
	   int k;
	   int lnode;
	   int rnode;
	   int min1;
	   int min2;

	   // 所有结点的相关域设置初值为-1
		   for (i = 0; i < 2 * n - 1; i++)
		      ht[i].parent = ht[i].lchild = ht[i].rchild = -1;
	   for (i = n; i < 2 * n - 1; i++) // 构造哈夫曼树的分支结点
		   {
		      min1 = min2 = 32767;
		      lnode = rnode = -1;
		      for (k = 0; k <= i - 1; k++) // 查找最小和次小的结点
			      {
			         if (ht[k].parent == -1) // 只在尚未构造二叉树的结点中查找
				         {
				            if (ht[k].weight < min1)
					            {
					               min2 = min1;
					               rnode = lnode;
					               min1 = ht[k].weight;
					               lnode = k;
					            }
				            else if (ht[k].weight < min2)
					            {
					               min2 = ht[k].weight;
					               rnode = k;
					            }
				         }
			      }
		      ht[lnode].parent = i; // 合并两个最小和次小的结点
		      ht[rnode].parent = i;
		      ht[i].weight = ht[lnode].weight + ht[rnode].weight; // 计算双亲结点的权重
		      ht[i].lchild = lnode; // 设置双亲结点的左孩子
		      ht[i].rchild = rnode; // 设置双亲结点的右孩子
		   }
}

/*-------------由哈夫曼树ht构造哈夫曼编码hcd-----------------*/
void create_huffman_code(HTNode ht[], HCode hcd[], int n)
{
	   int i;
	   int f;
	   int c;
	   HCode hc;

	   for (i = 0; i < n; i++) // 根据哈夫曼树构造所有叶子结点的哈夫曼编码
		   {
		      hc.start = n;
		      c = i;
		      f = ht[i].parent;
		      while (f != -1) // 循环直到树根结点
			      {
			         if (ht[f].lchild == c) // 处理左孩子结点
				            hc.cd[hc.start--] = '0';
			         else // 处理右孩子结点
				            hc.cd[hc.start--] = '1';
			         c = f;
			         f = ht[f].parent;
			      }
		      hc.start++; // start指向哈夫曼编码最开始字符
		      hcd[i] = hc;
		   }
}

/*-------------输出哈夫曼编码-----------------*/
void display_huffman_code(HTNode ht[], HCode hcd[], int n)
{
	   int i;
	   int k;
	   int sum = 0;
	   int m = 0;
	   int j;

	   printf("输出哈夫曼编码:\n");
	   for (i = 0; i < n; i++)
		   {
		      j = 0;
		      printf("    %s:\t", ht[i].data);
		      for (k = hcd[i].start; k <= n; k++)
			      {
			         printf("%c", hcd[i].cd[k]);
			         j++;
			      }
		      m += ht[i].weight;
		      sum += ht[i].weight * j;
		      printf("\n");
		   }

	   printf("\n平均长度 = %g\n", 1.0 * sum / m);
}

int main()
{
	   int n = 15;
	   int i;
	   HTNode ht[M];
	   HCode hcd[N];
	   char *str[] = { "The", "of", "a", "to", "and", "in", "that", "he", "is", "at", "on", "for", "His", "are", "be" };
	   int fnum[] = { 1192, 677, 541, 518, 462, 450, 242, 195, 190, 181, 174, 157, 138, 124, 123 };

	   for (i = 0; i < n; i++)
		   {
		      strcpy(ht[i].data, str[i]);
		      ht[i].weight = fnum[i];
		   }
	   create_huffman_tree(ht, n); // 创建哈夫曼树
	   create_huffman_code(ht, hcd, n); // 构造哈夫曼编码
	   display_huffman_code(ht, hcd, n); // 输出哈夫曼编码
	   
	   system("pause");
	   return 0;
}

在这里插入图片描述

陌生人你好.
关注
专栏目录
编写算法求二叉树结点x的双亲
weixin_45999886的博客
10-29 1064
【代码】编写算法求二叉树结点x的双亲。
数据结构--二叉树--双亲、孩子和兄弟节点的查询（顺序结构）
热门推荐
复兴之路
08-10 1万+
#include /* EOF(=^Z或F6),NULL */ #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ #if CHAR typedef char TElemType; TElemType
数据结构-二叉树（通过先序和中序或者是中序和后序得到二叉树）
代码屋-CODE HOUSE
04-13 1065
先序序列：ABDEHJKLMNCFGI中序序列：DBJHLKMNEAFCGI后序序列：DJLNMKHEBFIGCA#include &lt;iostream&gt; #include&lt;stdio.h&gt; #include&lt;malloc.h&gt; #include&lt;string.h&gt; using namespace std; typedef struct node { ...
用二叉树排序树的作用c语言,C语言数据结构之二叉树排序
weixin_39866487的博客
05-16 491
一、定义与性质定义二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：①若它的左子树非空，则左子树上所有结点的值均小于根结点的值；②若它的右子树非空，则右子树上所有结点的值均大于根结点的值；③左、右子树本身又各是一棵二叉排序树。上述性质简称二叉排序树性质(BST性质)，故二叉排序树...
数据结构之树和二叉树(ppt 92页).pptx
09-22
【数据结构之树和二叉树】是计算机科学中重要的基础知识，主要研究树形数据结构的定义、特性和操作。本部分重点讲解了树和二叉树的基本概念、术语、性质以及相关的操作。 首先，**树的定义**是数据结构中的核心概念...
数据结构之树和二叉树.pptx
10-04
数据结构中的树是一种非常...总结来说，树和二叉树是数据结构中的基础部分，它们提供了对复杂数据组织的有效抽象。理解和掌握这些概念对于解决计算机科学中的许多问题，如文件系统、编译器设计、网络路由等都至关重要。
实验3 | 由遍历序列构造二叉树
月雲之霄的博客
08-25 4189
二叉树构造定理： 定理7.1：任何n（n&gt;0）个不同结点的二又树，都可由它的中序序列和先序序列唯一地确定。   定理7.2：任何n（n＞0）个不同结点的二又树，都可由它的中序序列和后序序列唯一地确定。 1.1 已知先序序列为ABDGCEF，中序序列为DGBAECF，则构造二叉树的过程如下所示。  1.1.1 C代码： #include&lt;stdio.h&gt; #inclu...
二叉树相关算法
Bright的博客
11-19 175
void CreateTree(BTNode* &amp;b, char str[]) { int i = 0; BTNode *tstack[MaxSize], *bb; int top = -1; int k = 0; while (str[i]) { switch (str[i]) { case '(': tstack[++top] = bb; i++; k = 1...
二叉树：编写一个函数int Depth(BiTNode *T)。函数功能：计算二叉树的深度。
刘珂的博客
10-08 2195
#include <stdio.h> #include <malloc.h> typedef struct BiTNode { int data; //关键字项 struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode; BiTNode...
数据结构 关于树的几个证明题及代码实现
奋进的小白粥
02-21 2384
一、求二叉树的深度typedef struct BTNode BTNode{ Elemtype data; struct BTNode *lchild,*rchild; } BTNode; int depth(BTNode *T){ if(!T) return 0; int ldepth = depth(T-&gt;lchild); int rdepth = depth(T-&...
编写一个程序exp5-3.cpp，实现由先序序列和中序序列构造一颗二叉树的功能。通过输入先序序列“ABDEHJKLMNCFGI”和中序序列“DBJHLKMNEAFCGI”构造一个二叉树，并打印输出该二
xx7755223的博客
10-19 1874
编写一个程序exp5-3.cpp，实现由先序序列和中序序列构造一颗二叉树的功能。通过输入先序序列“ABDEHJKLMNCFGI”和中序序列“DBJHLKMNEAFCGI”构造一个二叉树，并打印输出该二叉树。 btree同第一个 https://blog.csdn.net/xx7755223/article/details/109133739?utm_source=app exp5-3.cpp ...
C~排序算法
最新发布
weixin_60461563的博客
09-27 815
在C/C++中，有多种排序算法可供选择，每种算法都有其特定的应用场景和特点。下面介绍几种常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序，并给出相应的示例代码和解释。
数据结构：树、森林
pranaa的博客
09-24 820
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
考研数据结构——C语言实现插入排序
weixin_58879477的博客
09-24 380
C语言实现插入排序
优先级队列(堆)
wuweixiaoyue的博客
09-24 311
什么是优先级队列：队列是一种先进先出(FIFO)的数据结构，但如果操作的数据带有优先级并且我们需要处理优先级更高的队列，此时光用【队列】不太合适，故而我们引入了【优先级队列(PriorityQueue)】如何实现优先级队列：JDK1.8中的PriorityQueue底层使用了堆这种数据结构来模拟优先级队列概念：堆实际就是在完全二叉树的基础上进行了一些调整 + 以顺序存储(数组)的方式存储二叉树。
数据结构 - 排序算法
kaneki_lh的博客
09-23 430
①.经过一趟快速排序后，确认。②.对每一组 分别 / 交替 直接插入排序。①.对序列进行分组，增量为 d。③.逐渐减小增量 d。②.该基准将整个数组分为。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值