关于树的一些算法操作包含树的非递归遍历（c源代码）

 
 

//可直接运行

//武汉大学学号：2009301750002

#include<stdio.h>
#include<stdlib.h>
#include <string.h>
typedef char BTElemtype;
typedef struct Node
{
BTElemtype data;
struct Node *lch;
struct Node*rch;
}BTNode;
typedef struct Snode
{
BTNode*  pointer;
struct Snode*next;
}Sqnode;
typedef struct ss
{
Sqnode*  top;
int stacksize;
}LinkStack;
typedef struct queuenode
{
BTNode*  pointer;
struct queuenode *next;
}Qnode;
typedef struct qq
{
Qnode*rear;
Qnode*front;
int queuesize;
}LinkQueue;
void initstack(LinkStack*s)
{

s->top=NULL;
s->stacksize=0;
}
void initqueue(LinkQueue*q)
{
Qnode*temp=(Qnode*)malloc(sizeof(Qnode));
temp->next=NULL;
q->front=temp;
q->rear=temp;
q->queuesize=0;
}
void push(LinkStack*s,BTNode*point)
{
s->stacksize++;
Sqnode*temp=(Sqnode*)malloc(sizeof(Sqnode));
temp->next=s->top;
temp->pointer=point;
s->top=temp;
}
void enqueue(LinkQueue*q,BTNode*point)
{
q->queuesize++;
Qnode*temp=(Qnode*)malloc(sizeof(Qnode));
temp->next=NULL;
temp->pointer=point;
q->rear->next=temp;
q->rear=temp;
}
BTNode* pop(LinkStack*s)
{
BTNode*pp;

if(s->stacksize==0)
{
return NULL;
}
else
{      pp=s->top->pointer;
s->top=s->top->next;
s->stacksize--;
return(pp);
}

}
BTNode*dequeue(LinkQueue*q)
{
BTNode*pp;
Qnode*p;
if(q->queuesize==0)
{
return NULL;
}
else
{
p=q->front->next;
pp=p->pointer;
q->front->next=p->next;
if(q->rear==p)
q->rear=q->front;
free(p);
q->queuesize--;
return(pp);
}
}
int stackempty(LinkStack*s)
{
return s->stacksize;
}
int queueempty(LinkQueue*q)
{
return q->queuesize;
}
BTNode* Gettop(LinkStack*s)
{
if(s->stacksize==0)
return 0;// printf("the number you input is error\n");
else
{return(s->top->pointer);
}

}
BTNode*CreateBiTree()
{
BTNode*root;
BTElemtype ch;
//scanf("%c",&ch);
ch=getchar();
if(ch=='#')
return NULL;
root=(BTNode*)malloc(sizeof(BTNode));
root->data=ch;
root->lch=CreateBiTree();
root->rch=CreateBiTree();
return root;
}
void PrintLeaf(BTNode*T)
{
if (!T) return ;
printf("(");
if (T->lch ) PrintLeaf(T->lch);
printf("%c", T->data);
if (T->rch ) PrintLeaf(T->rch );
printf(")");
}//end printLeaf

void PrintTree (BTNode*T)
{
printf("(");
PrintLeaf(T);
printf(")\n");
}//end printTree

void PreOrderTraverse(BTNode*T)
{
if (T)
{
printf("%c",T->data);
PreOrderTraverse(T->lch);
PreOrderTraverse(T->rch);

}

}

void RecruitPreOrderTraverse(BTNode*&T)
{
printf("\nPreOrderTraverse is ");
LinkStack*s=(LinkStack*)malloc(sizeof(LinkStack));
BTNode*  p;
initstack(s);
push(s,T);
while((stackempty(s))!=0)
{
while((p=Gettop(s)))
{
printf("%c",p->data);

push(s,p->lch);
}
p=pop(s);
if((stackempty(s))!=0)
{
p=pop(s);
push(s,p->rch);
}
}
}
void InOrderTraverse(BTNode*T)
{
if (T)
{
InOrderTraverse(T->lch);
printf("%c",T->data);
InOrderTraverse(T->rch);
}

}

void RecruitInOrderTraverse(BTNode*&T)
{
LinkStack*s=(LinkStack*)malloc(sizeof(LinkStack));
BTNode*  p;
initstack(s);
push(s,T);
printf("\nInOrderTraverse is ");
while((stackempty(s))!=0)
{

while((p=Gettop(s)))
{
push(s,p->lch);

}
p=pop(s);
if((stackempty(s))!=0)
{
p=pop(s);
printf("%c",p->data);
push(s,p->rch);
}
}
}
/*
void RecruitInOrderTraverse(BTNode*T)
{
LinkStack*s=(LinkStack*)malloc(sizeof(LinkStack));
BTNode*  p=T;
initstack(s);
while((stackempty(s))!=0||p)
{
if(p)
{
push(s,T);
p=p->lch;
}
else
{
p=pop(s);
printf("%c",p->data);
p=p->rch;
}
}

}
*/
void PostTraverse(BTNode*T)
{

if (T)
{
PostTraverse(T->rch);
PostTraverse(T->lch);
printf("%c",T->data);
}

}
void RecruitPostTraverse(BTNode*&T)
{
LinkStack*S=(LinkStack*)malloc(sizeof(LinkStack));
BTNode*  p,*l, *r;
initstack(S);
push(S, T);
while(stackempty(S))
{
p = pop(S);
l = p->lch;
r = p->rch;
if (l == NULL && r == NULL)
{
printf("%c", p->data);
}
else
{
p->lch = NULL;
p->rch = NULL;
push(S, p);
if (r != NULL) push(S, r);
if (l != NULL) push(S, l);
}
}

}
void Levelordertraverse(BTNode*&T)
{
printf("\nLevelOrderTraverse is ");
LinkQueue*q=(LinkQueue*)malloc(sizeof(LinkQueue));
BTNode*  p;
initqueue(q);
enqueue(q,T);
while(queueempty(q))
{
p=dequeue(q);
printf("%c",p->data);
if(p->lch!=NULL)
enqueue(q,p->lch);
if(p->rch!=NULL)
enqueue(q,p->rch);
}
}
int height(BTNode*T)
{
int hl,hr;
if(T==NULL) return 0;
hl=height(T->lch);
hr=height(T->rch);
return (hl>hr?(hl+1):(hr+1));
}
int degree0(BTNode* T)
{
int n=0;
if(T==NULL) return 0;
if(T->lch==NULL&&T->rch==NULL)
n=1;
if(T->lch!=NULL)
n+=degree0(T->lch);
if(T->rch!=NULL)
n+=degree0(T->rch);
return n;

}
int Recruitdegree0(BTNode*&T)
{
int n=0;
LinkStack*s=(LinkStack*)malloc(sizeof(LinkStack));
BTNode*  p;
initstack(s);
push(s,T);
while((stackempty(s))!=0)
{
while((p=Gettop(s)))
{
if(p->lch==NULL&&p->rch==NULL)
n+=1;

push(s,p->lch);
}
p=pop(s);
if((stackempty(s))!=0)
{
p=pop(s);
push(s,p->rch);
}
}
return n;
}
int degree1(BTNode* T)
{
int n=0,m=0,sum=0;
if(T==NULL) return 0;
if(T->lch!=NULL&&T->rch==NULL)
n=1;
n+=degree1(T->lch);
if(T->lch==NULL&&T->rch!=NULL)
m=1;
m+=degree1(T->rch);
sum=m+n;
return sum;
}
int Recruitdegree1(BTNode*&T)
{
int n=0;
LinkStack*s=(LinkStack*)malloc(sizeof(LinkStack));
BTNode*  p;
initstack(s);
push(s,T);
while((stackempty(s))!=0)
{
while((p=Gettop(s)))
{
if(p->lch!=NULL&&p->rch==NULL)
n+=1;
if(p->lch==NULL&&p->rch!=NULL)
n+=1;

push(s,p->lch);
}
p=pop(s);
if((stackempty(s))!=0)
{
p=pop(s);
push(s,p->rch);
}
}
return n;
}
int degree2(BTNode* T)
{
int n=0;
if(T==NULL) return 0;
if(T->lch!=NULL&&T->rch!=NULL)
n=1;
if(T->lch!=NULL)
n+=degree2(T->lch);
if(T->rch!=NULL)
n+=degree2(T->rch);
return n;
}
int Recruitdegree2(BTNode*&T)
{
int n=0;
LinkStack*s=(LinkStack*)malloc(sizeof(LinkStack));
BTNode*  p;
initstack(s);
push(s,T);
while((stackempty(s))!=0)
{
while((p=Gettop(s)))
{
if(p->lch!=NULL&&p->rch!=NULL)
n+=1;

push(s,p->lch);
}
p=pop(s);
if((stackempty(s))!=0)
{
p=pop(s);
push(s,p->rch);
}
}
return n;
}
int leaf(BTNode* T)
{

if(T==NULL) return 0;
if(T->lch==NULL&&T->rch==NULL) return 1;
return leaf(T->lch)+leaf(T->rch);

}
int completeBITree(BTNode*T)
{
static int flag;
if(T)
if(degree1(T)>0&&(height(T->lch)>=height(T->rch)))
{flag=1;
}
else
{
completeBITree(T->lch);
completeBITree(T->rch);
}
return flag;
}
void iscompleteBITree(BTNode*T)
{
int i=completeBITree(T);
if(i==0)
printf("\n\aYES !\n");
else
printf("\nNO!\a\n\a\a");
}
void swap(BTNode*T)
{
if (T&&!(T->lch==NULL&&T->rch==NULL))
{
BTNode*temp;
swap(T->lch);
swap(T->rch);
temp=T->lch;
T->lch=T->rch;
T->rch=temp;
}

}
void menu(void){
printf("\n武汉大学\n");
printf("      Mune for Linear Table On BiTree Structure \n");
printf("------------------------------------------------------\n");
printf("     1. 生成一棵二叉树.             2. 二叉树的后序非递归遍历\n");
printf("     3. 二叉树的前序遍历            4. 求度分别为0、1、2的结点的数目\n");
printf("     5. 二叉树的前序非递归遍历      6. 非递归求度分别为0、1、2的结点的数目\n");
printf("     7. 二叉树的中序遍历            8. 按层次遍历二叉树\n");
printf("     9. 二叉树的中序非递归遍历      10. 求二叉树的高度\n");
printf("     11. 二叉树的后序遍历           12. 判断是否为完全二叉树，输出“Yes!”/“No!”\n");
printf("     13.交换每个结点的左右子树      14.对交换左右子树后的二叉树作中序遍历 \n");
printf("     15.打印二叉树                    0. Exit\n");
printf("------------------------------------------------------\n");

}
void main()
{  BTNode*tree;
printf("必须先建立一个二叉树，以#表示NULL，且字符的输入必须连续不能中断的，先序遍历建立法\n");
tree=CreateBiTree();
int op=0;
do{   menu();
printf("          Please input your option[0-12]:");
scanf("%d",&op);
switch(op){
case 0: break;
case 1: printf("\n   生成一棵二叉树.\n");
tree=CreateBiTree();
break;
case 2: printf("\n     二叉树的后序非递归遍历\n");
PostTraverse(tree);
break;
case 3: printf("\n     二叉树的前序遍历\n");
printf("遍历次序为：");
PreOrderTraverse(tree);
break;
case 4: printf("\n  求度分别为0、1、2的结点的数目\n");
printf("度为0的节点有 ：%d\n",degree0(tree));
printf("度为1的节点有 ：%d\n",degree1(tree));
printf("度为2的节点有 ：%d\n",degree2(tree));
break;
case 5: printf("\n   二叉树的前序非递归遍历 \n");
RecruitPreOrderTraverse(tree);
break;
case 6: printf("\n   非递归求度分别为0、1、2的结点的数目\n");
printf("度为0的节点有 ：%d\n",Recruitdegree0(tree));
printf("度为1的节点有 ：%d\n",Recruitdegree1(tree));
printf("度为2的节点有 ：%d\n",Recruitdegree2(tree));
break;
case 7: printf("\n   二叉树的中序遍历\n");
printf("遍历次序为：");
InOrderTraverse(tree);
printf("\n");
break;
case 8: printf("\n   按层次遍历二叉树\n");
Levelordertraverse(tree);
break;
case 9: printf("\n     二叉树的中序非递归遍历 \n");
RecruitInOrderTraverse(tree);
break;
case 10: printf("\n     求二叉树的高度\n");
printf("二叉树的高度为：%d \n",height(tree));
break;
case 11: printf("\n   二叉树的后序遍历 \n");
PostTraverse(tree);
break;
case 12: printf("\n    判断是否为完全二叉树，输出Yes!/No! \n");
iscompleteBITree(tree);
break;
case 13: printf("\n    交换每个结点的左右子树 \n");
swap(tree);
break;
case 14: printf("\n    对交换左右子树后的二叉树作中序遍历 \n");
swap(tree);
InOrderTraverse(tree);
swap(tree);
break;
case 15: printf("\n    打印二叉树 \n");
PrintTree(tree);
break;
default: printf("\n你所输入的没有意义\n");
}
}while(op);
}

 

《数据结构》实验
 
试 验 二
1．设某二叉树的结点类型为整数类型，以二叉链表形式作为存储结构。试编程实现：

(1) 生成一棵二叉树.

(2) 用递归算法、非递归算法实现二叉树的遍历；

(3) 求度分别为0、1、2的结点的数目,分别用递归算法、非递归算法实现；

(4) 按层次遍历二叉树(提示：使用一个队列实现）；

*(5) 求二叉树的高度(深度)；

*(6) 判断是否为完全二叉树，输出"Yes!"/"No!"；

*(7) 交换每个结点的左右子树；

*(8) 对交换左右子树后的二叉树作中序遍历。

 
用文件形式存放二叉树，同时能从文件中读入保存的二叉树。

测试实验：

   首先建立一颗树

     




 

1.    前序遍历

 

2.    中序遍历

 

3.    后序遍历

 

4.    求读为012的节点数目

 

5.    层次遍历

 

6.    求树的高度

 

7.    判断是否为完全二叉树

 

8.    对交换左右子树的二叉树做中序遍历

 

9.    打印二叉树