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

最新推荐文章于 2021-11-03 17:11:59 发布
最新推荐文章于 2021-11-03 17:11:59 发布
阅读量1.8k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 算法 c tree null struct structure
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouyelihua/article/details/6700068
版权
 

 

 //可直接运行

//武汉大学学号：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.    打印二叉树

 

 

zhouyelihua
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构树的各种操作算法源代码
06-19
对树的各种操作，其中包括生成树的各种方式，递归和非递归算法，二叉排序树的递归和非递归算法，各种遍历的递归和非递归算法，包括求得二叉树的层数和叶子数。 对学习数据结构有很好的帮助。
二叉树层次遍历
黄坤的博客
03-26 330
算法如下： void LevelOrder(BiTree T){ InitQueue(Q); //初始话辅助队列 BiTree p; EnQueue(Q,T); //将根节点入队 while(!IsEmpty(Q)){ //队列不为空循环 DeQueue(Q ,p); //队头结点入队 visit(p); //访问出队结点 if(p->lchild!=NULL) ...
java孩子兄弟链表构造,树的二叉链表(孩子-兄弟)存储结构的基本操作
weixin_39610415的博客
03-21 845
typedef struct CSNode{TElemType data;CSNode *firstchild,*nextsibling;}CSNode,*CSTree;//树的二叉链表(孩子-兄弟)存储结构的基本操作(17)个# define ClearTree DestroyTreevoid InitTree(CSTree &T){T = NULL;}void DestroyTree(...
二叉树的相关算法
李昂的博客
11-03 1244
1、二叉树的先序遍历递归与非递归 void preorder(BiTree T) { if(T != NULL) { visit(); preorder(T->lchild); preorder(T->rchild); } } //一直入栈往左走，到头出栈掉个头 void preorder(BiTree T) { InitStack(S); p = T: while(p != NULL || !StackEmpty(S)) { if(
小议Enqueue
lanmh的专栏
11-10 425
本文简单描述了一下enqueue的基本概念，结构和一些相关的参数，希望对于加深enqueue的理解有点帮助。     什么是enqueue enqueue可以做名词，也可以做动词来解释。做名词时，指的的是一种锁的类型，比如Tx enqueue。做动词时，则是指将锁请求放入到请求队列的操作。 我们知道，lock是一种需要排队的锁实现机制，这和latch是不一样的，latch是一种轻量级的锁，是不需要...
Enqueue（队列等待）
逝鸿的博客
09-18 9914
参考自盖国强《深入解析oracle》 Enqueue 是一种保护共享资源的锁定机制。该锁定机制保护共享资源，以避免因并发操作而损坏数据，比如通过锁定保护一行记录，避免多个用户同时更新。Enqueue 采用排队机制，即 FIFO（先进先出）来控制资源的使用。 Oracle 在数据库内部用 Enqueue 等待来记录锁定，通过 Latch Free 等待事件来记录闩。Enqueue 等待常见的有
算法课设（非常详细文档，源代码都有）
07-04
课程的拓扑排序问题 二叉树的非递归先序遍历 矩阵的加减乘操作
二叉树的各种遍历 递归非递归
06-17
数据结构中二叉树的各种遍历，先序、中序、后序、层次、节点层次判断、交换左右子树、相似等的递归与非递归算法的源代码。
经典数据结构算法c语言实现代码（大全）
09-11
16进制10进制.txt 32.txt asm.txt Crctable.txt C标志符命名源程序.txt erre.txt ... 非递归.txt 顺序栈.txt 顺序表.txt 顺序队列.txt 骑士遍历1.txt 骑士遍历2.txt 骑士遍历回逆.txt 黑白.txt
数据结构及算法C语言实现代码集[推荐下载]
11-10
非递归.c ./硬币情况: for循环的.c 硬币分法.c ./逆阵: 简单逆阵.c 逆矩阵.c 逆阵.c ./问题算法: N皇后问题回溯算法.c 万年历 动态计算网络最长最短路线.c 矩阵乘法动态规划.c 网络最短路径Dijkstra...
二叉树的遍历（递归+非递归 c语言版）
11-05
结构清晰地介绍了二叉树的遍历方法，附带详细的注释，希望像能对和我一样入门级的朋友们有所帮助
二叉树的遍历（递归和非递归的先中后序）
12-02
本程序为c语言实现的二叉树的遍历，从递归和非递归两个方向实现了对二叉树的前中后的遍历。代码量有300+行，可以用c的编译器直接打开，代码注释部分可以直接输入进行测试。
分层遍历二叉树
yychenxie21的专栏
09-15 722
1，问题：给定一棵二叉树，要求按分层遍历该二叉树，即从上到下按层次访问该二叉树（每一次将单独输出一行），每一层要求访问的顺序为从左到右，并将结点依次编号。      解法一：基本思想：用层序遍历的方法，初始化一个队列，当每一层结点进队时，统计当前层的下一层结点数目，当结点出队时，统计出队次数是不是和上一层结点数目相等，若相等，则表明上一层的结点输出完毕，换行；否则不换行打印，继续统计当前层的下一
二叉树的层次遍历
qq_34941153的博客
08-30 141
void LevelOrder(TNode* &T) { Queue Q; InitQueue(Q); EnQueue(Q,T); while(QueueEmpty(Q)!=true) { DeQueue(Q,T); visit(T); if(T->lchild!=NULL) ...
数据结构教程（第四版）P85~87//队列的链式存储结构
computerfeiwu的博客
01-08 345
这个代码一开始出了点问题，在进队列时没有将next指针置为NULL导致后面数据出错，不过好在，我问了一个朋友，才发现这个问题。 在此我要对我这位朋友表示感谢！3Q温小姐 #include #include #include #include typedef int ELemType; typedef struct Node { ELemType data; struct Node *
enqueue的种类
NinGoo's Notes
12-06 3786
在x$ksqst中，还提供了一个说明列，用于解释在什么场景下会产生该enqueue。下面是oracle10.2.0.1中的一个例子：select distinct ksqsttyp,ksqstexpl from x$ksqst order by ksqsttyp; No KSQSTTYP
Enqueue 整理总结
02-10 432
nqueue 整理总结 建议大家看看原文 文档区可以下到..《Wait.Interface.A.Practical.Guide.to.Performance.Diagnostics.and.Tuning》 这本书写的...
拓扑排序的c语言实现
热门推荐
zhouyelihua
08-01 1万+
以下的介绍是百度上的，因为这个实在太老了。但是只是单纯自己的一个程序显得不是很完整的。呵呵   　　通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。离散数学中关于偏序和全序的定义： 　　若集合X上的关系是R是自反的、反对称的和传递的，则称R是集合X上的偏序关系。
已知入栈顺序的n个元素求合理的出栈序列有多少种
zhouyelihua
09-08 9647
在这里先介绍一下好括号序列       好括号序列是指它有一半的走括号和一半的右括号组成，在这个序列中任意找一个空左边的序列右括号数目一定不超过左括号数。）（且从左向右看这个括号序列，看到的右括号数目不超过左括号数。）       下面介绍求证有n个左括号组成的好括号列的个数
请写出二叉树非递归遍历算法、递归遍历算法 、层次遍历算法的伪代码。
最新发布
06-08
好的，下面是二叉树非递归遍历算法、递归遍历算法、层次遍历算法的伪代码： 1. 二叉树非递归遍历算法（中序遍历） ``` 非递归中序遍历二叉树(root为二叉树根节点)： 1. 将root节点入栈； 2. 当栈不为空时，取出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值