数据结构树实验

头文件

#include<stdio.h>
#include<stdlib.h>
//二叉链表存储结构

typedef char elementType;
typedef struct lbnode
{
    elementType data;//定义数据类型
    struct lbnode *lchild,*rchild;//定义左右孩子指针
}BiNode,*BTree;//定义树 ,BTree为指向结构体的指针
int temp = 0;
int line = 0;
int len;
//构建二叉树
//构建子树函数
void createsubtree(BiNode *q,int k)
{
  BiNode *u;
  elementType x;
  scanf("%c",x);
  if(x!='#')
  {
    u=(BTree) malloc(sizeof(BiNode));
    u->data=x;
    u->lchild=NULL;
    u->rchild=NULL;
    if(k==1)
    {
       q->lchild=u;//定义的类型,1则为左子树
    }
    if(k==2)
    {
       q->rchild=u;//2则为右子树
    }
    createsubtree(u,1);
    createsubtree(u,2);
  }
}
//创建二叉树函数
void creatBitree(BiNode *bt)
{
BiNode *p;
char x;
printf("请按照先序序列输入二叉树（‘#’表示无子树）");
scanf("%c",&x);
if(x=='#')
return;
bt=(BTree) malloc(sizeof(BiNode));
bt->data=x;
bt->lchild=NULL;
bt->rchild=NULL;
p=bt;
createsubtree(p,1);
createsubtree(p,2);
}
//遍历算法的实现
//先序遍历
void PreTraverseBTree(BiNode * pT)//使用递归的思想
{
    if(pT != NULL)
    {
        printf("%c ",pT->data);
        if(pT->lchild != NULL)
        {
            PreTraverseBTree(pT->lchild);
        }
        if(pT->rchild!= NULL)
        {
            PreTraverseBTree(pT->rchild);
        }
    }
}
//中序遍历
void InTraverseBTree(BiNode * pT)
{
    if(pT != NULL)
    {
        if(pT->lchild != NULL)
        {
            InTraverseBTree(pT->lchild);
        }
        printf("%c ",pT->data);
        if(pT->rchild != NULL)
        {
            InTraverseBTree(pT->rchild);
        }
    }
}
//后序遍历
void PostTraverseBTree(BiNode * pT)
{
    if(pT != NULL)
    {
        if(pT->lchild != NULL)
        {
            PostTraverseBTree(pT->lchild);
        }
        if(pT->rchild != NULL)
        {
            PostTraverseBTree(pT->rchild);
        }
        printf("%c ",pT->data);
    }
}
//输出各个节点的值并且输出其层数
void PreOrderTraverse(BiNode *T,int level)
{
    
    if(T)
    {
        printf("节点 %c 位于第 %d 层\n", T -> data, level);
        PreOrderTraverse(T -> lchild, level+1);
        PreOrderTraverse(T -> rchild, level+1);
    }
}
//求二叉树的高度
int Max(int a, int b)
{
    printf("二叉树的高度为：");
	return a > b ? a : b;
}
int Height(BiNode* pRoot)
{
	if (pRoot == NULL)
	{
		return 0;
	}
	int left = Height(pRoot->lchild);
	int right = Height(pRoot->rchild);
	return Max(left, right) + 1;
}

// 获取二叉树中节点的个数 
int GetNodeCount(BiNode  *pRoot)
{
	if (pRoot == NULL)
	{
		return 0;
	}
	int left = GetLeafNodeCount(pRoot->lchild);
	int right = GetLeafNodeCount(pRoot->rchild);

	return left + right + 1;
}
//求二叉树中的叶子节点树
int GetLeafNodeCount(BiNode* pRoot)
{
	if (pRoot == NULL)
	{
		return 0;
	}
	else if (pRoot->lchild== NULL && pRoot->rchild == NULL)
	{
		return 1;
	}
	else
	{
		int left = GetLeafNodeCount(pRoot->lchild);
		int right = GetLeafNodeCount(pRoot->rchild);

		return left + right ;
	}
}

//求二叉树度为2的节点数
int NodeCount (BiNode  *T)
{
	int count=0;
	if(T!=0)
	{
		if(T->lchild&&T->rchild)//*如果左右都有，那么count++*/ 
		{
		count++;
		count+=NodeCount(T->lchild);
		count+=NodeCount(T->rchild);
		}
		else
		{
		count+=NodeCount(T->lchild);
		count+=NodeCount(T->rchild);
		}
	}
	return count;
}
//求任意一个字母对应的左右孩子及其兄弟
void find_tree(BiNode *p, char ch)
 {
     int a = 1, b = 1, c = 1;
     temp = 0;
     line = 0;
     findfother_tree(p, ch);
     if(temp != -1)
     {
         a = 0;
     }
     temp = 0;
     line = 0;
     findbrother_tree(p, ch);
     if(temp != -1)
     {
         b = 0;
     }
     temp = 0;
     line = 0;
     findchild_tree(p, ch);
     if(temp != -1)
     {
         c = 0;
     }
     if(a == 0 && b == 0 && c == 0)
     {
         printf("该节点没有兄弟，双亲，孩子节点\n");
         return;
     }
     if(a == 0)
     {
         printf("该节点没有双亲节点!\n");
     }
     if(b == 0)
     {
         printf("该节点没有兄弟节点!\n");
     }
     if(c == 0)
     {
         printf("该节点没有孩子节点!\n");
     }
 }
//查找双亲节点
void findfother_tree(BiNode *p, char ch)
 {
     if(p)
     {
         if(p->rchild)
         {
             if(p->rchild->data == ch)
             {
                    temp = -1;
                    printf("该节点的双亲节点为：%c\n", p->data);
             }
         }
         if(p->lchild)
         {
             if(p->lchild->data == ch)
             {
                    temp = -1;
                    printf("该节点的双亲节点为：%c\n", p->data);
             }
         }
         if(temp == -1)
         {
             return;
         }
         findfother_tree(p->lchild, ch);
         findfother_tree(p->rchild, ch);
     }
 }
 //查找兄弟节点
void findbrother_tree(BiNode *p, char ch)
 {
     if(p)
     {

         if(p->rchild && p->lchild)
         {
             if(p->lchild->data == ch)
             {
                    temp = -1;
                    printf("该节点的右兄弟节点为：%c\n", p->rchild->data);
             }
             if(p->rchild->data == ch)
             {
                    temp = -1;
                    printf("该节点的左兄弟节点为：%c\n", p->lchild->data);
             }
         }
         if(temp == -1)
         {
             return;
         }
         findbrother_tree(p->lchild, ch);
         findbrother_tree(p->rchild, ch);
     }
 }
 //查找孩子节点
void findchild_tree(BiNode *p, char ch)
 {
     if(p)
     {
         if(p->lchild)
         {
             if(p->data == ch)
             {
                 temp = -1;
                 printf("该节点的左孩子节点为：%c\n", p->lchild->data);
             }
         }
         if(p->rchild)
         {
             if(p->data == ch)
             {
                 temp = -1;
                 printf("该节点的右孩子节点为：%c\n", p->rchild->data);
             }
         }
         if(temp == -1)
         {
             return;
         }
         findchild_tree(p->lchild, ch);
         findchild_tree(p->rchild, ch);
     }
 }


//输入x求其在树中的层次
int depth(BiNode *q,char x)
{
	int L=1;
	if(q!=NULL)
	{
		if(q->data==x)
		printf("层号：%d",L);
		return 1;
	}
	L++;
	depth(q->lchild,x);
	depth(q->rchild,x);
	L--;
}
//将数组中的元素转换为二叉链表形式

void TranstoTable(BiNode *T, char K[], int i)
 {
	if (K[i] != '/') 
    {
		BiNode* temp = (BTree) malloc(sizeof(BiNode));   //用来申请新的空间
		temp->data = K[i];
		temp->lchild = temp->rchild = NULL;
		T = temp;
		TranstoTable(T->lchild, K, 2 * i);  //每次通过改变左右指针的空间来继续创建
		TranstoTable(T->rchild, K, 2 * i + 1);
	}
	else
	{
		T = NULL;  //此时表示这个结点的位置为空
	}
}



//交换二叉树的左右孩子

void Swap(BiNode  *T1, BiNode* T2)//交换两个二叉树结点指针的指向
{
    BiNode  *t=T1;
    T1=T2;
    T2=t;
}
void NodeSwap(BiNode  *T)//交换二叉树每个结点的左孩子和右孩子
{
    //此算法根据二叉树先序遍历算法改造而来
    if(T!=NULL)
    {
        if(T->lchild!=NULL&&T->rchild!=NULL)//如果T的左孩子和右孩子都不空
        {
            //将"交换二叉树每个结点的左孩子和右孩子"转换为"交换二叉树每个结点的左孩子的数据域和右孩子的指针域".
            Swap(T->lchild,T->rchild);
        }
        else if(T->lchild!=NULL&&T->rchild==NULL)//如果T的左孩子不空且右孩子为空
        {
            //将T的左子树变为右子树
            T->rchild=T->lchild;
            T->lchild=NULL;
        }
        else if(T->lchild==NULL&&T->rchild!=NULL)//如果T的左孩子为空且右孩子不为空
        {
            //将T的右子树变为左子树
            T->lchild=T->rchild;
            T->rchild=NULL;
        }
        else//如果T的左孩子和右孩子都为空
        {
            //空操作
            ;
        }
        NodeSwap(T->lchild);
        NodeSwap(T->rchild);
    }
    else
    {
        ;
    }
}

主函数

```c

```c
#include"Bitree.h"
#include <stdio.h>
#include <string.h>
#include  <stdlib.h>
int  main()
{
    BiNode *q;
	int n;
    int k=1;
   char x;
   int m;
   char a[m];
   int i=1;

   do
    {
		printf("请选择你想要实现的功能\n");
        printf("-------0.构建二叉树----------\n");
		printf("-------1.先序遍历二叉树------------\n");
		printf("-------2.中序遍历二叉树-------\n");
		printf("-------3.后序遍历二叉树--------\n");
		printf("-------4.输出各个节点的值并且输出其对应的层次数--\n");
		printf("-------5.求二叉树高度-----\n");
		printf("-------6.求二叉树节点数-------------\n");
		printf("-------7.求二叉树叶子节点数--------\n");
        printf("-------8.求二叉树度为2的节点数-----\n");
        printf("-------9. 输入元素x求其父亲，兄弟节点，并且指出左右节点------\n");
        printf("-------10.输入元素x求其在树中的层次------\n");  
        printf("-------11.按顺序方式将数组中的二叉树转换为二叉链表形式--------\n");
        printf("-------12.交换二叉树的左右孩子------\n");
        scanf("%d",&n);
        switch(n)
        {
    case 0:
            system("CLS");
            creatBitree(q);
           	system("Pause");
			break;
    case 1:
            system("CLS");
			printf("先序遍历的结果为：");
            PreTraverseBTree(q);
			system("Pause");
			break;
    case 2:
            system("CLS");
			
			printf("中序遍历的结果为：");
            InTraverseBTree(q);
            system("Pause");
			break;
    case 3:
            system("CLS");
			printf("后序遍历的结果为");
            PostTraverseBTree(q);
			system("Pause");
			break;
    case 4:
        system("CLS");
			printf("各个节点输出结果如下");
            PreOrderTraverse(q,k);
			system("Pause");
			break;
    case 5:
        system("CLS");
			printf("二叉树的高度为:");
            Height(q);
			system("Pause");
			break;
    case 6:
        system("CLS");
			printf("二叉树的节点数为:");
            GetNodeCount(q);
			system("Pause");
			break;
    case 7:
        system("CLS");
			printf("二叉树的叶子节点数为:");
            GetLeafNodeCount(q);
			system("Pause");
			break;
    case 8:
        system("CLS");
			printf("二叉树度为2的节点数为:");
            NodeCount(q);
			system("Pause");
			break;
    case 9:
        system("CLS");
        printf("请输入元素：");
        scanf("%c",&x);
		find_tree(q, x);
		system("Pause");
		break;
    case 10:
        system("CLS");
        printf("请输入元素：");
        scanf("%c",&x);
		depth(q, x);
        system("Pause");
		break;
    case 11:
    system("CLS");
    printf("请输入数组的长度");
    scanf("%d",&m);
    printf("请输入元素");
    for(i=1;i<=m;i++)
    {
        scanf("%c",&a[i]);
    }
    TranstoTable(q, a[m], 1);
    system("Pause");
	break;
    case 12:
        system("CLS");
        NodeSwap(q);
        system("Pause");
		break;
    default:
    
			printf("Selection is error!\n");
			system("Pause");
    }
	} while (1);
  return 0;
}