_DataStructure_C_Impl:二叉树的二叉链表存储结构

最新推荐文章于 2024-07-12 16:35:20 发布
最新推荐文章于 2024-07-12 16:35:20 发布
阅读量80 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/javafly/p/6037140.html
版权 
// _DataStructure_C_Impl:
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
typedef char DataType;
typedef struct Node{		//二叉链表存储结构类型定义
	DataType data;			//数据域
	struct Node *lchild;	//指向左孩子结点
	struct Node *rchild;	//指向右孩子结点
}*BiTree,BitNode;
//二叉树的初始化操作
void InitBitTree(BiTree *T){
	*T=NULL;
}
//销毁二叉树操作
void DestroyBitTree(BiTree *T){
	if(*T){		//如果是非空二叉树
		if((*T)->lchild)
			DestroyBitTree(&((*T)->lchild));
		if((*T)->rchild)
			DestroyBitTree(&((*T)->rchild));
		free(*T);
		*T=NULL;
	}
}
//递归创建二叉树
void CreateBitTree(BiTree *T){
	DataType ch;
	scanf("%c",&ch);
	if(ch=='#')
		*T=NULL;
	else{
		*T=(BiTree)malloc(sizeof(BitNode));	//生成根结点
		if(!(*T))
			exit(-1);
		(*T)->data=ch;
		CreateBitTree(&((*T)->lchild));	//构造左子树
		CreateBitTree(&((*T)->rchild));	//构造右子树
	}
}
//二叉树的左插入操作
int InsertLeftChild(BiTree p,BiTree c){
	if(p){		//如果指针p不空
		c->rchild=p->lchild;	//p的原来的左子树成为c的右子树
		p->lchild=c;	//子树c作为p的左子树
		return 1;
	}
	return 0;
}
//二叉树的右插入操作
int InsertRightChild(BiTree p,BiTree c){
	if(p){		//如果指针p不空
		c->rchild=p->rchild;	//p的原来的右子树作为c的右子树
		p->rchild=c;		//子树c作为p的右子树
		return 1;
	}
	return 0;
}
//查找元素值为e的结点的指针
BiTree Point(BiTree T,DataType e){
	BiTree Q[MaxSize];	//定义一个队列，用于存放二叉树中结点的指针
	int front=0,rear=0;	//初始化队列
	BitNode *p;
	if(T){	//如果二叉树非空
		Q[rear]=T;
		rear++;

		while(front!=rear){	//如果队列非空
			p=Q[front];	//取出队头指针
			front++;	//将队头指针出队
			if(p->data==e)
				return p;
			if(p->lchild){	//如果左孩子结点存在，将左孩子指针入队
				Q[rear]=p->lchild;	//左孩子结点的指针入队
				rear++;
			}
			if(p->rchild){	//如果右孩子结点存在，将右孩子指针入队
				Q[rear]=p->rchild;	//右孩子结点的指针入队
				rear++;
			}
		}
	}
	return NULL;
}
//返回二叉树的左孩子结点元素值操作
DataType LeftChild(BiTree T,DataType e){
	BiTree p;
	if(T){		//如果二叉树不空
		p=Point(T,e);	//p是元素值e的结点的指针
		if(p&&p->lchild)		//如果p不为空且p的左孩子结点存在
			return p->lchild->data;		//返回p的左孩子结点的元素值
	}
	return 0;
}
//返回二叉树的右孩子结点元素值操作
DataType RightChild(BiTree T,DataType e){
	BiTree p;
	if(T){
		p=Point(T,e);		//p是元素值e的结点的指针
		if(p&&p->rchild)		//如果p不为空且p的右孩子结点存在
			return p->rchild->data;		//返回p的右孩子结点的元素值
	}
	return 0;
}
//二叉树的左删除操作
int DeleteLeftChild(BiTree p){
	if(p){
		DestroyBitTree(&(p->lchild));	//删除左子树
		return 1;
	}
	return 0;
}
//二叉树的右删除操作
int DeleteRightChild(BiTree p){
	if(p){
		DestroyBitTree(&(p->rchild));	//删除右子树
		return 1;
	}
	return 0;
}
//==================================================
//利用括号嵌套的字符串建立二叉链表
void CreateBitTree2(BiTree *T,char str[]){
	char ch;
	BiTree stack[MaxSize];	//定义栈，用于存放指向二叉树中结点的指针
	int top=-1;		//初始化栈顶指针
	int flag,k;
	BitNode *p;
	*T=NULL;
	k=0;
	ch=str[k];
	while(ch!='\0'){	//如果字符串没有结束
		switch(ch){
		case '(':
			stack[++top]=p;
			flag=1;
			break;
		case ')':
			top--;
			break;
		case ',':
			flag=2;
			break;
		default:
			p=(BiTree)malloc(sizeof(BitNode));
			p->data=ch;
			p->lchild=NULL;
			p->rchild=NULL;
			if(*T==NULL)	//如果是第一个结点，表示是根结点
				*T=p;
			else{
				switch(flag){
				case 1:
					stack[top]->lchild=p;
					break;
				case 2:
					stack[top]->rchild=p;
					break;
				}
			}
		}
		ch=str[++k];
	}
}
//先序遍历二叉树的递归实现
void PreOrderTraverse(BiTree T){
	if(T){
		printf("%2c",T->data);		//访问根结点
		PreOrderTraverse(T->lchild);//先序遍历左子树
		PreOrderTraverse(T->rchild);//先序遍历右子树
	}
}
//中序遍历二叉树的递归实现
void InOrderTraverse(BiTree T){
	if(T){
		InOrderTraverse(T->lchild);//中序遍历左子树
		printf("%2c",T->data);		//访问根结点
		InOrderTraverse(T->rchild);//中序遍历右子树
	}
}
//后序遍历二叉树的递归实现
void PostOrderTraverse(BiTree T){
	if(T){
		PostOrderTraverse(T->lchild);//后序遍历左子树
		PostOrderTraverse(T->rchild);//后序遍历右子树
		printf("%2c",T->data);		//访问根结点
	}
}
//先序遍历二叉树的非递归实现
void PreOrderTraverse2(BiTree T){
	BiTree stack[MaxSize];	//定义一个栈，用于存放结点的指针
	int top;		//定义栈顶指针
	BitNode *p;	//定义一个结点的指针
	top=0;	//初始化栈
	p=T;
	while(p!=NULL||top>0){
		while(p!=NULL){	//如果p不空，访问根结点，遍历左子树
			printf("%2c",p->data);	//访问根结点
			stack[top++]=p;	//将p入栈
			p=p->lchild;	//遍历左子树
		}
		if(top>0){	//如果栈不空
			p=stack[--top];		//栈顶元素出栈
			p=p->rchild;		//遍历右子树
		}
	}
}
//中序遍历二叉树的非递归实现
void InOrderTraverse2(BiTree T){
	BiTree stack[MaxSize];	//定义一个栈，用于存放结点的指针
	int top;		//定义栈顶指针
	BitNode *p;	//定义一个结点的指针
	top=0;	//初始化栈
	p=T;
	while(p!=NULL||top>0){
		while(p!=NULL){	//如果p不空，访问根结点，遍历左子树
			stack[top++]=p;	//将p入栈
			p=p->lchild;	//遍历左子树
		}
		if(top>0){	//如果栈不空
			p=stack[--top];		//栈顶元素出栈
			printf("%2c",p->data);	//访问根结点
			p=p->rchild;		//遍历右子树
		}
	}
}
//后序遍历二叉树的非递归实现
void PostOrderTraverse2(BiTree T){
	BiTree stack[MaxSize];	//定义一个栈，用于存放结点的指针
	int top;		//定义栈顶指针
	BitNode *p,*q;	//定义一个结点的指针
	top=0;	//初始化栈
	p=T;
	q=NULL;
	while(p!=NULL||top>0){
		while(p!=NULL){	//如果p不空，访问根结点，遍历左子树
			stack[top++]=p;	//将p入栈
			p=p->lchild;	//遍历左子树
		}
		if(top>0){	//如果栈不空
			p=stack[top-1];	//取栈顶元素
			if(p->rchild==NULL||p->rchild==q){	//如果p没有右孩子结点，或右孩子结点已经访问过
				printf("%2c",p->data);	//访问根结点
				q=p;
				p=NULL;
				top--;
			}else
				p=p->rchild;
		}
	}
}
void main_Traverse(){
	BiTree T,root;
	InitBitTree(&T);
	printf("根据输入二叉树的先序序列创建二叉树('#'表示结束)：\n");
	//ABD#G##EH##I##CF#J###
	CreateBitTree(&T);
	printf("二叉树的先序序列：\n");
	printf("递归：\t");
	PreOrderTraverse(T);
	printf("\n");
	printf("非递归：");
	PreOrderTraverse2(T);
	printf("\n");
	printf("二叉树的中序序列：\n");
	printf("递归：\t");
	InOrderTraverse(T);
	printf("\n");
	printf("非递归：");
	InOrderTraverse2(T);
	printf("\n");
	printf("二叉树的后序序列：\n");
	printf("递归：\t");
	PostOrderTraverse(T);
	printf("\n");
	printf("非递归：");
	PostOrderTraverse2(T);
	printf("\n");
	printf("根据括号嵌套的字符串建立二叉树:\n");
	CreateBitTree2(&root,"(a(b(c,d),e(f(,g),h(i)))");
	printf("二叉树的先序序列：\n");
	PreOrderTraverse(root);
	printf("\n");
	printf("二叉树的中序序列：\n");
	InOrderTraverse(root);
	printf("\n");
	printf("二叉树的后序序列：\n");
	PostOrderTraverse(root);
	printf("\n");
	DestroyBitTree(&T);
	DestroyBitTree(&root);
	system("pause");
}
//===================================================
//按层次打印二叉树中的结点
void LevelPrint(BiTree T){
	BiTree queue[MaxSize];	//定义一个队列，用于存放结点的指针
	BitNode *p;
	int front,rear;	//定义队列的队头指针和队尾指针
	front=rear=-1;	//队列初始化为空
	rear++;			//队尾指针加1
	queue[rear]=T;	//将根结点指针入队
	while(front!=rear){	//如果队列不为空*
		front=(front+1)%MaxSize;
		p=queue[front];	//取出队头元素
		printf("%c",p->data);	//输出根结点
		if(p->lchild!=NULL){	//如果左孩子不为空，将左孩子结点指针入队
			rear=(rear+1)%MaxSize;
			queue[rear]=p->lchild;
		}
		if(p->rchild!=NULL){	//如果右孩子不为空，将右孩子结点指针入队
			rear=(rear+1)%MaxSize;
			queue[rear]=p->rchild;
		}
	}
}
//按树状打印的二叉树
void TreePrint(BiTree T,int level){
	int i;
	if(T==NULL)	//如果指针为空，返回上一层
		return ;
	TreePrint(T->rchild,level+1);	//打印右子树，并将层次加1
	for(i=0;i<level;i++)	//按照递归的层次打印空格
		printf("	");
	printf("%c\n",T->data);	//输出根结点
	TreePrint(T->lchild,level+1);	//打印左子树，并将层次加1
}
//******************
void main_Print(){
	BiTree T,root;
	printf("根据括号嵌套(a(b(c,d),e(f(,g),h(i)))建立二叉树:\n");
	CreateBitTree2(&T,"(a(b(c,d),e(f(,g),h(i)))");
	printf("按层次输出二叉树的序列：\n");
	LevelPrint(T);
	printf("\n");
	printf("按树状打印二叉树：\n");
	TreePrint(T,1);
	printf("根据括号嵌套(A(B(D(,H),E(,I)),C(F,G)))建立二叉树:\n");
	CreateBitTree2(&root,"(A(B(D(,H),E(,I)),C(F,G)))");
	printf("按层次输出二叉树的序列：\n");
	LevelPrint(root);
	printf("\n");
	printf("按树状打印二叉树：\n");
	TreePrint(root,1);
	DestroyBitTree(&T);
	DestroyBitTree(&root);
	system("pause");
}
//==============================
//统计二叉树中叶子结点数目
int LeafCount(BiTree T){
	if(!T)				//如果是空二叉树，返回0
		return 0;
	else 
		if(!T->lchild&&!T->rchild)		//如果左子树和右子树都为空，返回1
			return 1;
		else
			return LeafCount(T->lchild)+LeafCount(T->rchild);		//将左子树叶子结点个数与右子树叶子结点个数相加
}
//统计二叉树中非叶子结点数目
int NotLeafCount(BiTree T){
	if(!T)		//如果是空二叉树，返回0
		return 0;
	else if(!T->lchild&&!T->rchild)		//如果是叶子结点，返回0
		return 0;
		else
			return NotLeafCount(T->lchild)+NotLeafCount(T->rchild)+1;		//左右子树的非叶子结点数目加上根结点的个数

}
//统计二叉树中结点数目
int TreeCount(BiTree T){
	if(T==NULL)
		return 0;
	return 1+TreeCount(T->lchild)+TreeCount(T->rchild);
}
//计算二叉树的深度
int BitTreeDepth(BiTree T){
	if(T == NULL) 
		return 0;
	return 
		BitTreeDepth(T->lchild)>BitTreeDepth(T->rchild)?1+BitTreeDepth(T->lchild):1+BitTreeDepth(T->rchild);
}
int Depth(BiTree T)
{
	if(T == NULL) 
		return 0;

	if(T->lchild==NULL&&T->rchild==NULL)
		return 1;
	return 
		Depth(T->lchild)>Depth(T->rchild) ? 1+Depth(T->lchild) : 1+Depth(T->rchild);
}
void main_Count(){
	BiTree T,root;
	int num,depth;
	printf("根据括号嵌套(a(b(c,d),e(f(,g),h(i)))建立二叉树:\n");
	CreateBitTree2(&root,"(a(b(c,d),e(f(,g),h(i)))");
	num=TreeCount(root);
	printf("二叉树结点个数=%2d\n",num);
	num=LeafCount(root);
	printf("叶子结点个数=%2d\n",num);
	num=NotLeafCount(root);
	printf("非叶子结点个数=%2d\n",num);
	depth=BitTreeDepth(root);
	printf("二叉树的深度=%2d\n",depth);
	printf("根据括号嵌套(A(B(D(,H(J)),E(,I(K,L))),C(F,G)))建立二叉树:\n");
	CreateBitTree2(&T,"(A(B(D(,H(J)),E(,I(K,L))),C(F,G)))");
	num=LeafCount(T);
	printf("叶子结点个数=%2d\n",num);
	num=NotLeafCount(T);
	printf("非叶子结点个数=%2d\n",num);
	depth=BitTreeDepth(T);
	printf("二叉树的深度=%2d\n",depth);
	DestroyBitTree(&T);
	DestroyBitTree(&root);
	system("pause");
}
void main(){
	main_Traverse();
	main_Print();
	main_Count();
}

转载于:https://www.cnblogs.com/javafly/p/6037140.html

weixin_30840573
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树的二叉链表存储结构
weixin_30840253的博客
08-22 1724
// c6-2.h 二叉树的二叉链表存储结构(见图6.7) typedef struct BiTNode { TElemType data; BiTNode *lchild,*rchild; // 左右孩子指针 }BiTNode,*BiTree;二叉树的二叉链表存储结构删除和插入结点或子树都很灵活。结点动态生成，可充分 利用存储空间。图68是图61(a)所示二叉树的二叉链表存储结构。...
Notes_DataStructure_and_Algorithms：数据结构和算法的注释
02-15
这份"Notes_DataStructure_and_Algorithms"的压缩包很可能包含了关于这些主题的详细注释，可能包括各种数据结构（如数组、链表、栈、队列、树、图等）和算法（如排序、搜索、图遍历等）的解释。 1. **数组**：数组...
二叉树的存储结构
AnalogElectronic的博客
06-04 361
#include<stdio.h> #include<stdlib.h> typedef char ElemType; typedef char DataType; //二叉树的顺序存储结构 #define MAXNODE 100 typedef ElemType SqBiTree[MAXNODE+1]; void main() { SqBiTree a; i...
【数据结构】存储二叉树节点的栈 C language
xpisme
11-29 1885
栈 后进先出（Last In First Out） 使用C中的数组实现 存储二叉树节点的栈#include <stdio.h> #include <stdlib.h>// 定义二叉树节点 struct node { int data; struct node *left; struct node *right; } node;// 定义栈，栈的长度为100 stru
2021数据结构CH05【树与二叉树】
qq_39413850的博客
10-14 401
5.3.3 3. #include<stdio.h> #include<stdlib.h> #define maxsize 5 #define ElemType int//假设元素类型为int typedef struct BiTree{ ElemType data; struct BiTNode *lchild,*rchile; }BiTNode,*BiTree; typedef struct{ ElemType stack[maxsize];
创建二叉树的二叉链表存储结构
AnalogElectronic的博客
06-07 2万+
#include<stdio.h> #include<stdlib.h> #include<string.h> #define MAXLEN 100 typedef char ElemType; typedef char DataType; //二叉链表存储结构 typedef struct BiTNode { DataType data; stru...
data_structure_c.rar_Datastructure_data_structure_c_二叉树_二叉树 c++_
09-20
本资料包"Data_structure_c.rar"聚焦于C语言实现的数据结构，特别是链表和二叉树这两种重要结构，同时涵盖了它们的排序算法。 链表是一种线性数据结构，每个元素（节点）包含数据以及指向下一个节点的引用。链表...
7个数据结构的实验_DataStructure.rar_操作系统_数据结构 实验
09-20
在"7个数据结构的实验_DataStructure.rar_操作系统_数据结构 实验"这个压缩包中，包含了用Visual C++ 6.0在Windows 2000/XP环境下编写的几个数据结构实验程序，这些程序对于深入理解和应用数据结构有着重要的作用。...
程序设计与数据结构.周立功单片机.pdf_Datastructure_c_c语言周立功_machineryl7x_program
09-29
《程序设计与数据结构》是周立功针对C语言编程及数据结构的一本经典教材，适合C语言初学者以及希望深化理解的读者。书中详细介绍了C语言的基础语法、编程技巧，以及如何通过C语言实现数据结构，同时也涉及到了一些...
2018380039_DataStructure_Lab_datastructure_
10-03
数据结构是指一组数据的存储结构，它可以是线性的，如数组、链表；也可以是非线性的，如树、图。这些结构设计的目的是为了提高数据的访问和操作效率，为算法设计提供基础。 1. **数组**：是最基本的数据结构，它将...
建立一棵用二叉树链表方式存储的二叉树，并对其进行遍历（先序，中序和后序），打印输出遍历结果
热门推荐
小白的Coding之旅
11-04 6万+
题目如下 代码如下 #include&amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;malloc.h&amp;amp;amp;amp;gt; typedef struct Node//结构体 { char data;
exit(0)、exit(1)、exit(-1)以及return的区别
矢月的博客
03-07 6002
exit(0)表示程序正常退出；除了0之外，其他参数均代表程序异常退出，如：exit(1),exit(-1)。 return；表示的是程序结束（return后没有参数是因为void函数不返回任何值才会这样用），return和exit作用大致相同。 但是在函数中就会有所区别，return会跳出函数，而exit会结束程序。 在栈的编写，发现代码中有exit()；和return;函数 r...
输出给定二叉树的嵌套括号表示(java)
心中的利剑：HTML5 Canvas游戏动画（JavaScript）
08-21 704
题：对于下图的二叉树，输出其嵌套括号表示 [img]http://dl.iteye.com/upload/attachment/0072/3033/114e5346-bf3e-3bf5-b696-7bfbf260a382.gif[/img] [code="java"]import java.util.*; public class BinaryTree { ...
LCR 155. 将二叉搜索树转化为排序的双向链表
weixin_61067952的博客
07-09 266
中序遍历可以得到排序的序列，遍历时维护当前节点和前一个节点，改变左右指针。头节点设为null，遍历开始判断一下然后初始化。尾节点中序遍历时一直更新。
7.10飞书一面面经
东篱君的博客
07-10 1151
B+树的⾮叶⼦节点不存放实际的记录数据，仅存放索引，所以数据量相同的情况下，相⽐存储即存索引⼜存记录的 B 树，B+树的⾮叶⼦节点可以存放更多的索引，因此 B+ 树可以⽐ B 树更「矮胖」，查询底层节点的磁盘 I/O次数会更少。主从复制：单节点Redis的并发能力是有上限的，要进一步提高Redis的并发能力，可以搭建主从集群，实现读写分离。B+ 树有⼤量的冗余节点（所有⾮叶⼦节点都是冗余索引），这些冗余索引让 B+ 树在插⼊、删除的效率都更⾼，⽐如删除根节点的时候，不会像 B 树那样会发⽣复杂的树的变化；
[高频 SQL 50 题(基础版)]第一千七百五十七题，可回收且低脂产品
weixin_45201305的博客
07-10 274
low_fats 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品是低脂产品，'N' 表示不是低脂产品。recyclable 是枚举类型，取值为以下两种 ('Y', 'N')，其中 'Y' 表示该产品可回收，而 'N' 表示不可回收。没什么难度，作为基础题五十题的第一题练手，现在也开始陆续写一些SQL，作为记录，和leetcode一起，大家都加油。编写解决方案找出既是低脂又是可回收的产品编号。是该表的主键（具有唯一值的列）。
leetcode--验证二叉搜索树
liulanba的博客
07-09 662
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。有效 二叉搜索树定义如下：节点的左子树只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。所有左子树和右子树自身必须也是二叉搜索树。示例 1：输入：root = [2,1,3]输出：true示例 2：输入：root = [5,1,4,null,null,3,6]输出：false解释：根节点的值是 5 ，但是右子节点的值是 4。提示：树中节点数目范围在[1, 104] 内。
Redis数据结构-String篇
最新发布
时间如瑾 代码如诗
07-12 665
对⼀个内部表示成long型的string执行append, setbit, getrange这些命令，针对的仍然是string的值（即⼗进制表示的字符串），而不是针对内部表⽰的long型进⾏操作。因此，在这些命令的实现中，会把long型先转成字符串再进行相应的操作。String 的内部存储结构⼀般是 sds（Simple Dynamic String，可以动态扩展内存），但是如果⼀个String 类型的 value 的值是数字，那么 Redis 内部会把它转成 long 类型来存储，从⽽减少内存的使用。
数据结构-41
08-03
第 四 章 串学习要点1 了解串的基本操作，了解利用这些基本操作实现串的其它操作的方法；2 掌握在串的堆分配存储结构下，串的基本操作算法；3 掌握在串的模式匹配

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值