二叉树的基本操作 C语言版的

Posted 2023-03-20

1.对任意给定的二叉树（顶点数自定）建立它的二叉链表存储结构，并实现二叉树的先序、中序、后序三种遍历，输出三种遍历的结果。
2． 求二叉树高度、结点数、度为1的结点数和叶子结点数

#include <stdio.h>/* 头文件 */
#include <stdlib.h>
#include <malloc.h>
typedef struct BiTNode/* 定义节点 */

char data;/* 元素类型为字符 */
struct BiTNode *lchild,*rchild;/* 左孩子右孩子 */

BiTNode,*BiTree;
BiTree CreateBiTree()/* 用先序递归建树 */

char p;BiTree T;
scanf("%c",&p);
if(p==' ') T=NULL;
else

T=(BiTNode *)malloc(sizeof(BiTNode));/* 开辟空间 */
T->data=p;
T->lchild=CreateBiTree();
T->rchild=CreateBiTree();

return (T);

int Leaves(BiTree T)/* 叶子结点个数 */

int num1,num2;
if(T==NULL)
return(0);
if(T->lchild==NULL&&T->rchild==NULL)
return(1);
num1=Leaves(T->lchild);
num2=Leaves(T->rchild);
return(num2+num1);

void main()/* 主函数 */

BiTree Ta;
int num;
printf("请创建树\n");
Ta=CreateBiTree();
num=Leaves(Ta);
printf("叶子数为：\n");
printf("%d",num);

这个会不啊，http://zhidao.baidu.com/question/155464460.html 谢谢

#include <iostream.h>
typedef struct BiTNode

char data;
int bit;
struct BiTNode *lchild,*rchild,*parent;
BiTNode;

void InitBT(BiTNode *&t)//1、初始化，不带头结点

t=NULL;


/*void InitBT(BiTNode *t)//初始化，带头结点

t=new BiTNode;
t->lchild=t->rchild=t->parent=NULL;
*/

int EmptyBT(BiTNode *t)//判断队空

if(t==0)
return 1;
else
return 0;


BiTNode *creatBT(BiTNode *t,int b)//2、创建二叉树

BiTNode *p;
char ch;
cin>>ch;
if(ch=='#')return 0;
else

p=new BiTNode;
p->data=ch;
p->parent=t;
p->bit=b;
t=p;
t->lchild=creatBT(t,0);
t->rchild=creatBT(t,1);

return t;


void preorder(BiTNode *t)//3、先序遍历

if(!EmptyBT(t))

cout<<t->data;
preorder(t->lchild);
preorder(t->rchild);



void inorder(BiTNode *t)//中序遍历

if(!EmptyBT(t))

inorder(t->lchild);
cout<<t->data;
inorder(t->rchild);



void postorder(BiTNode *t)//后序遍历

if(!EmptyBT(t))

postorder(t->lchild);
postorder(t->rchild);
cout<<t->data;



void coutBT(BiTNode *t,int &m,int &n,int &i)//4、计算二叉树中叶子结点、度为2的结点和度为1的结点的个数

if(!EmptyBT(t))

if((t->lchild==0) && (t->rchild==0))
m++;//叶子结点
else if((t->lchild!=0) && (t->rchild!=0))
i++;//度为2的结点
else
n++;//度为1的结点
coutBT(t->lchild,m,n,i);
coutBT(t->rchild,m,n,i);



void coutNode(BiTNode *t,int &k)//5、求二叉树中结点个数

if(!EmptyBT(t))

k++;
coutNode(t->lchild,k);
coutNode(t->rchild,k);



int BTdepth(BiTNode *t)//6、求二叉树的深度

int i,j;
if(EmptyBT(t))
return 0;
else

i=BTdepth(t->lchild);
j=BTdepth(t->rchild);
return (i>j?i:j)+1;



int Xdepth(BiTNode *t,char x)//7、查找x的层数

int num1,num2,n;
if(t==NULL)
return 0;
else
if(t->data==x)
return 1;
num1=Xdepth(t->lchild,x);
num2=Xdepth(t->rchild,x);
n=num1+num2;
if(num1!=0||num2!=0)
n++;
return n;



static int flag;
void SearchChild(BiTNode *t,int k)//8、查找第k个结点的左右孩子

if(!EmptyBT(t))

if(k==0)

cout<<"位置不能为0!"<<endl;
return;

else

flag++;
if(flag==k)

if(t->lchild==0)
cout<<"无左孩子! ";
else
cout<<"左孩子为："<<(t->lchild->data)<<" ";
if(t->rchild==0)
cout<<"无右孩子!"<<endl;
else
cout<<"右孩子为："<<(t->rchild->data)<<endl;

else

SearchChild(t->lchild,k);
SearchChild(t->rchild,k);





int Xancestor(BiTNode *t,char x)//9、查找x结点祖先

int n,num1,num2;
if(t==NULL)
return 0;
else

if(t->data==x)
return 1;
num1=Xancestor(t->lchild,x);
num2=Xancestor(t->rchild,x);
n=num1+num2;
if(n!=0)

n++;
cout<<t->data<<" "<<endl;




void BTNodePath(BiTNode *t)//10、输出所有叶子结点路径

if(!EmptyBT(t))

if((t->lchild==0) && (t->rchild==0))

cout<<t->data<<"的路径为：";
for(BiTNode *p=t;p!=0;p=p->parent)
cout<<p->data;
cout<<endl;

else

BTNodePath(t->lchild);
BTNodePath(t->rchild);




void BTNodebit(BiTNode *t)//11、输出所有叶子结点编码

if(!EmptyBT(t))

if((t->lchild==0) && (t->rchild==0))

cout<<t->data<<"的编码为：";
for(BiTNode *p=t;p->parent!=0;p=p->parent)
cout<<p->bit;
cout<<endl;

else

BTNodebit(t->lchild);
BTNodebit(t->rchild);




void main()

BiTNode *t;
int m,n,i,d,q,k;
char x;
cout<<"1、初始化..."<<endl;
InitBT(t);

cout<<"2、创建二叉树..."<<endl;
t=creatBT(t,0);

cout<<"3.1、先序遍历..."<<endl;
preorder(t);
cout<<endl;
cout<<"3.2、中序遍历..."<<endl;
inorder(t);
cout<<endl;
cout<<"3.3、后序遍历..."<<endl;
postorder(t);
cout<<endl;

m=n=i=0;
cout<<"4、计算叶子结点，度为1的结点和度为2的结点的个数..."<<endl;
coutBT(t,m,n,i);
cout<<"叶子结点个数为："<<m<<endl;
cout<<"度为1的结点个数为："<<n<<endl;
cout<<"度为2的结点个数为："<<i<<endl;

q=0;
cout<<"5、计算结点个数..."<<endl;
coutNode(t,q);
cout<<"结点个数为："<<q<<endl;

d=0;
cout<<"6、计算深度..."<<endl;
d=BTdepth(t);
cout<<"深度为："<<d<<endl;

cout<<"7、求x的层数..."<<endl;
cout<<"输入x：";
cin>>x;
if(Xdepth(t,x)==0)
cout<<"x不存在！"<<endl;
else
cout<<Xdepth(t,x)<<endl;

cout<<"8、输入要查找孩子的结点在先序遍历中的位置k（不等于0）：";
cin>>k;
SearchChild(t,k);
if(k>flag)
cout<<"位置超出长度!"<<endl;

cout<<"9、查询结点的所有祖先，请输入结点x：";
cin>>x;
int num;
num=Xancestor(t,x);
if(num==0)
cout<<"结点不存在！"<<endl;
if(num==1)
cout<<"根结点无祖先！"<<endl;

cout<<"10、输出所有叶子结点路径（叶→根）："<<endl;
BTNodePath(t);

cout<<"11、输出所有叶子结点编码（叶→根）："<<endl;
BTNodebit(t);
参考技术A #include<stdio.h>
#include<malloc.h>
int count=0;
typedef struct BiTNode // 结点结构
char data;
struct BiTNode *lchild, *rchild; // 左右孩子指针
BiTNode, *BiTree;

void CreateBiTree(BiTree &T)
char ch;
scanf("%c",&ch);
if(ch=='#')T=NULL;
else
if(!(T = (BiTNode * )malloc(sizeof(BiTNode)))) return;
T->data=ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);

//CreatBiTree
int PreOrder(BiTree T)//先序遍历二叉树的递归算法

if (!T) return 0;
printf("%c ",T->data); // 访问结点
PreOrder(T->lchild); // 遍历左子树
PreOrder(T->rchild);// 遍历右子树
return 1;

int InOrder(BiTree T)//先序遍历二叉树的递归算法

if (!T) return 0;

InOrder(T->lchild); // 遍历左子树
printf("%c ",T->data); // 访问结点
InOrder(T->rchild);// 遍历右子树
return 1;

int PostOrder(BiTree T)//先序遍历二叉树的递归算法

if (!T) return 0;

PostOrder(T->lchild); // 遍历左子树
PostOrder(T->rchild);// 遍历右子树
printf("%c ",T->data); // 访问结点
return 1;

int CountLeaf (BiTree T)
//返回指针T所指二叉树中所有叶子结点个数
if (!T ) return 0;//空树
if (!T->lchild && !T->rchild) return 1;//只有树根
int m;
int n;
m = CountLeaf( T->lchild);

n = CountLeaf( T->rchild);

return (m+n);

// CountLeaf

void main()
int a;
BiTree T;
CreateBiTree(T);
printf("先序遍历：");
PreOrder(T);
printf("中序遍历：");
InOrder(T);
printf("后序遍历：");
PostOrder(T);
a=CountLeaf(T);
printf("叶子节点个数：");
printf("%d",a);

数据结构C语言版——链式二叉树的基本操作实现

文章目录

• 链式二叉树
• • 1. 概念
  • 2. 链式二叉树的基本操作
  • • 前序遍历
    • 中序遍历
    • 后续遍历
    • 根据前序遍历构建二叉树
    • 层序遍历
    • 在二叉树中查找指定值
    • 获取二叉树节点个数
    • 获取叶子节点个数
    • 求二叉树的高度

---

链式二叉树

1. 概念

设计不同的节点结构可构成不同形式的链式存储结构。由二叉树的定义可知，二叉树的节点由一个数据元素分别指向其左右子树的两个分支构成，则表示二叉树的链表中的结点至少包含3个域：数据域和左右指针域，左右指针分别指向左右孩子所在的链节点的存储地址。

typedef char BTDataType;

typedef struct BinaryTreeNode

	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
BTNode;

2. 链式二叉树的基本操作

前序遍历

前序遍历又叫先根遍历，先遍历根节点再遍历左子树和右子树，而左子树和右子树又有根节点，这就是一个递归操作。就是按根左右的遍历方法。

比如下面这棵数的前序遍历就是ABDEHCFG

// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root)

	if (root == NULL)
	
		return;
	
	printf("%c ", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);

中序遍历

中序遍历中根遍历，它的遍历顺序就是先遍历左子树再遍历根节点再遍历右子树，也就是左根右。

这棵树的中序遍历就是DBEHAFCG

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)

	if (root == NULL)
	
		return;
	
	
	BinaryTreeInOrder(root->left);
	printf("%c ", root->data);
	BinaryTreeInOrder(root->right);

后续遍历

后续遍历也叫后根遍历，遍历的顺序是先左子树再右子树最后根节点，按照左右根来遍历二叉树。

下面这棵树的后续遍历就是DHEBFGCA

// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)

	if (root == NULL)
	
		return;
	
	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%c ", root->data);

根据前序遍历构建二叉树

给定一个字符串。是二叉树树的前序遍历ABD##E#H##CF##G##，其中#代表NULL，通过这个字符串构造一颗二叉树。

实现思路：

1. 函数三个参数，数组、字符串长度、数组下标，通过递归来构建
2. 递归的结束条件，数组遍历完了、或者是遇到#了
3. 每调用一次函数就让index加一
4. 最后返回节点

// 根据前序遍历构建二叉树
BTNode* BinaryTreeCreate(BTDataType* arr, int n, int* index)

	if (*index >= n || arr[*index] == '#')
	
		return NULL;
	
	BTNode* root = (BTNode*)(malloc(sizeof(BTNode)));
	root->data = arr[*index];
	(*index)++;
	root->left = BinaryTreeCreate(arr, n, index);
	(*index)++;
	root->right = BinaryTreeCreate(arr, n, index);

	return root;

层序遍历

层序遍历就是将二叉树按层一层一层遍历。

下面这个二叉树的层序遍历为ABCDEFGH

思路：

同过队列来进行广度优先搜索。

• 首先将根节点如队列，然后出队出队的同时将左右孩子入队列(注意左右孩子不为空)
• 出队前记录当前队列元素个数，出当前队列中的元素(避免刚入队的左右子树出队列)
• 当队列为空时说明层序遍历完成

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)

	Queue q = NULL,NULL;
	QueueInit(&q);
	QueuePush(&q,root);
	while (!QueueEmpty(&q))
	
		int size = QueueSize(&q);
		while (size--)
		
			BTNode* root = QueueFront(&q);
			printf("%c ", root->data);
			if (root->left != NULL)
			
				QueuePush(&q, root->left);
			
			if (root->right != NULL)
			
				QueuePush(&q, root->right);
			
			QueuePop(&q);
		
	

在二叉树中查找指定值

直接递归遍历二叉树，先找根节点再找左子树和右子树。

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)

	if (root == NULL)
	
		return NULL;
	
	if (root->data == x)
	
		return root;
	

	BTNode* left = BinaryTreeFind(root->left, x);
	if (left != NULL)
	
		return left;
	
	BTNode* right = BinaryTreeFind(root->right, x);
	if (right != NULL)
	
		return right;
	
	return NULL;

获取二叉树节点个数

这其实就时一个普通的遍历，通过递归将大事化小。整棵树的节点个数会等于：它的左子树节点个数加上右子树的节点个数再加上自己，也就是加一。

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)


	return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;

获取叶子节点个数

叶子节点右一个特点，就是它的左子树和右子树都为空，通过递归如果左右子树都为NULL就返回1，否则返回0,就能得到叶子节点个数。

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)

	if (root == NULL)
	
		return 0;
	
	if (root->left == NULL && root->right == NULL)
	
		return 1;
	

	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);

求二叉树的高度

二叉树的高度就是它的最大深度，相求一颗树的最大深度，就得先求出它的左右子树的最大深度，通过后续遍历到达叶子节点，从叶子节点开始不断求出左右子树的较大的那一棵子树再加一，开始不断向上返回就能得到一颗二叉树的最大深度。

int maxDepth(BTNode* root)
    if (root == NULL)
    
        return 0;
    
    int left = maxDepth(root->left);
    int right = maxDepth(root->right);

    return left > right ? left+1 : right+1;

从叶子节点开始不断求出左右子树的较大的那一棵子树再加一，开始不断向上返回就能得到一颗二叉树的最大深度。

int maxDepth(BTNode* root)
    if (root == NULL)
    
        return 0;
    
    int left = maxDepth(root->left);
    int right = maxDepth(root->right);

    return left > right ? left+1 : right+1;

---