zoukankan      html  css  js  c++  java
  • 二叉树的基本操作(C)

    实现二叉树的创建(先序)、递归及非递归的先、中、后序遍历

    请按先序遍历输入二叉树元素(每个结点一个字符,空结点为'='):
    ABD==E==CF==G==
    
    先序递归遍历:
    A B D E C F G
    中序递归遍历:
    D B E A F C G
    后序递归遍历:
    D E B F G C A
    层序递归遍历:
    ABCDEFG
    先序非递归遍历:
    A B D E C F G
    中序非递归遍历:
    D B E A F C G
    后序非递归遍历:
    D E B F G C A
    深度:
    3
    请按任意键继续. . .
      1 #include<stdio.h>
      2 #include<stdlib.h>
      3 
      4 #define OK 1
      5 #define ERROR 0
      6 #define TRUE 1
      7 #define FALSE 0
      8 #define OVERFLOW -1
      9 
     10 #define STACK_INIT_SIZE 100
     11 #define STACKINCREMENT 10
     12 
     13 typedef int Status;
     14 
     15 typedef char ElemType;
     16 typedef struct BTNode
     17 {
     18     ElemType data;
     19     struct BTNode *leftChild;
     20     struct BTNode *rightChild;
     21 }BTNode, *BinTree;
     22 
     23 typedef BinTree SElemType;
     24 
     25 typedef struct{//栈结构定义
     26     SElemType *base;
     27     SElemType *top;
     28     int stacksize;
     29 }SqStack;
     30 
     31 BinTree CreateBinTree(BinTree T);
     32 Status Visit(ElemType e);
     33 Status Depth(BinTree T);
     34 Status PreOrderRecursionTraverse(BinTree T, Status (*Visit)(ElemType e));
     35 Status InOrderRecursionTraverse(BinTree T, Status (*Visit)(ElemType e));
     36 Status PostOrderRecursionTraverse(BinTree T, Status (*Visit)(ElemType e));
     37 Status LevelOrderRecursionTraverse(BinTree T, Status (*Visit)(ElemType e));
     38 
     39 //定义栈的相关操作
     40 Status InitStack(SqStack *S);
     41 Status DestroyStack(SqStack *S);
     42 Status ClearStack(SqStack *S);
     43 Status StackEmpty(SqStack S);
     44 int StackLength(SqStack S);
     45 Status GetTop(SqStack S,SElemType *e);
     46 Status Push(SqStack *S,SElemType e);
     47 Status Pop(SqStack *S,SElemType *e);
     48 Status StackTraverse(const SqStack *S);
     49 
     50 Status PreOrderNoneRecursionTraverse(BinTree T, Status (*Visit)(ElemType e));
     51 Status InOrderNoneRecursionTraverse(BinTree T, Status (*Visit)(ElemType e));
     52 Status PostOrderNoneRecursionTraverse(BinTree T, Status (*Visit)(ElemType e));
     53 
     54 int main()
     55 {
     56     int depth;
     57     BinTree Tree = NULL;
     58     Status(*visit)(ElemType e) = Visit;  
     59     printf_s("请按先序遍历输入二叉树元素(每个结点一个字符,空结点为'='):
    ");  
     60     Tree = CreateBinTree(Tree);
     61 
     62     printf_s("
    先序递归遍历:
    ");
     63     PreOrderRecursionTraverse(Tree,visit);
     64     printf_s("
    中序递归遍历:
    ");
     65     InOrderRecursionTraverse(Tree,visit);
     66     printf_s("
    后序递归遍历:
    ");
     67     PostOrderRecursionTraverse(Tree,visit);
     68     printf_s("
    层序递归遍历:
    ");
     69     LevelOrderRecursionTraverse(Tree,visit);
     70 
     71     printf_s("
    先序非递归遍历:
    ");
     72     PreOrderNoneRecursionTraverse(Tree,visit);
     73     printf_s("
    中序非递归遍历:
    ");
     74     InOrderNoneRecursionTraverse(Tree,visit);
     75     printf_s("
    后序非递归遍历:
    ");
     76     PostOrderNoneRecursionTraverse(Tree,visit);
     77 
     78     printf_s("
    深度:
    ");
     79     depth = Depth(Tree);
     80     printf_s("%d
    ", depth);
     81     system("pause");
     82     return 0; 
     83 }
     84 
     85 //创建二叉树
     86 BinTree CreateBinTree(BinTree T)
     87 {
     88     char ch;
     89     scanf_s("%c", &ch);
     90     if (ch == '=')
     91     {
     92         T = NULL;
     93     }
     94     else
     95     {
     96         if (!(T=(BTNode *) malloc(sizeof(BTNode))))
     97         {
     98             exit(OVERFLOW);
     99         }
    100         T->data = ch;    //生成根结点
    101         T->leftChild = CreateBinTree(T->leftChild);
    102         T->rightChild = CreateBinTree(T->rightChild);
    103     }
    104     return T;
    105 }
    106 
    107 //访问二叉树
    108 Status Visit(ElemType e)
    109 {
    110     if (e == '')
    111     {
    112         return ERROR;
    113     }
    114     else
    115     {
    116         printf_s("%c ", e);
    117     }
    118     return OK;
    119 }
    120 
    121 //先序遍历递归算法
    122 Status PreOrderRecursionTraverse(BinTree T, Status (*Visit)(ElemType e))
    123 {
    124     if (T)
    125     {
    126         if (!Visit(T->data))
    127         {
    128             return ERROR;
    129         }
    130         PreOrderRecursionTraverse(T->leftChild, Visit);
    131         PreOrderRecursionTraverse(T->rightChild, Visit);
    132     }
    133     return OK;
    134 }
    135 
    136 //中序遍历递归算法
    137 Status InOrderRecursionTraverse(BinTree T, Status (*Visit)(ElemType e))
    138 {
    139     if (T)
    140     {
    141         InOrderRecursionTraverse(T->leftChild, Visit);
    142         if (!Visit(T->data))
    143         {
    144             return ERROR;
    145         }
    146         InOrderRecursionTraverse(T->rightChild, Visit);
    147     }
    148     return OK;
    149 }
    150 
    151 //后序遍历递归算法
    152 Status PostOrderRecursionTraverse(BinTree T, Status (*Visit)(ElemType e))
    153 {
    154     if (T)
    155     {
    156         PostOrderRecursionTraverse(T->leftChild, Visit);
    157         PostOrderRecursionTraverse(T->rightChild, Visit);
    158         if (!Visit(T->data))
    159         {
    160             return ERROR;
    161         }
    162     }
    163     return OK;
    164 }
    165 
    166 //层序遍历递归算法
    167 Status LevelOrderRecursionTraverse(BinTree T, Status (*Visit)(ElemType e))
    168 {
    169     if (T)
    170     {
    171         BTNode *Q[100];//假设不溢出
    172         int front = -1,rear = -1;
    173         if (T)
    174         {
    175             Q[++rear] = T;
    176             printf_s("%c", T->data);
    177             while (front != rear)
    178             {
    179                 BTNode *p;
    180                 if (!(p = (BTNode *)malloc(sizeof(BTNode))))
    181                 {
    182                     exit(OVERFLOW);
    183                 }
    184                 p = Q[++front];
    185                 if (p->leftChild)
    186                 {
    187                     Q[++rear] = p->leftChild;
    188                     printf("%c",p->leftChild->data);
    189                 }
    190                 if (p->rightChild)
    191                 {
    192                     Q[++rear] = p->rightChild;
    193                     printf("%c",p->rightChild->data);
    194                 }
    195             }
    196         }
    197     }
    198     return OK;
    199 }
    200 
    201 Status Depth(BinTree T)
    202 {
    203     int a,b;
    204     if (!T)
    205     {
    206         return ERROR;
    207     }
    208     else
    209     {
    210         a = Depth(T->leftChild) + 1;
    211         b = Depth(T->rightChild) + 1;
    212         return a > b ? a : b;
    213     }
    214 }
    215 
    216 //先序遍历非递归算法
    217 Status PreOrderNoneRecursionTraverse(BinTree T, Status (*Visit)(ElemType e))
    218 {
    219     SqStack S;
    220     SElemType p;
    221 
    222     InitStack(&S);
    223     Push(&S, T);
    224 
    225     while (!StackEmpty(S))
    226     {
    227         Pop(&S, &p);
    228         if (!Visit(p->data))
    229         {
    230             return ERROR;
    231         }
    232         if (p->leftChild)
    233         {
    234             Push(&S, p->rightChild);
    235         }
    236         if (p->rightChild)
    237         {
    238             Push(&S, p->leftChild);
    239         }
    240     }
    241     DestroyStack(&S);
    242     return OK;
    243 }
    244 
    245 //中序遍历非递归算法
    246 Status InOrderNoneRecursionTraverse(BinTree T, Status (*Visit)(ElemType e))
    247 {
    248     SqStack S;
    249     SElemType p;
    250 
    251     InitStack(&S);
    252     Push(&S, T);
    253     while (!StackEmpty(S))
    254     {
    255         while (GetTop(S,&p) && p)
    256         {
    257             Push(&S, p->leftChild);
    258         }
    259         Pop(&S, &p);
    260         if (!StackEmpty(S))
    261         {
    262             Pop(&S, &p);
    263             if (!Visit(p->data))
    264             {
    265                 return ERROR;
    266             }
    267             Push(&S, p->rightChild);
    268         }
    269     }
    270     DestroyStack(&S);
    271     return OK;
    272 }
    273 
    274 //后序便利非递归算法
    275 Status PostOrderNoneRecursionTraverse(BinTree T, Status (*Visit)(ElemType e))
    276 {
    277     SqStack S;
    278     SElemType p, q;
    279     InitStack(&S);
    280     Push(&S,T);
    281     while(!StackEmpty(S))
    282     {
    283         while(GetTop(S,&p)&&p&&(p->leftChild||p->rightChild))
    284         {
    285             Push(&S,p->rightChild);
    286             Push(&S,p->leftChild);
    287         }
    288         if(!StackEmpty(S)){
    289             Pop(&S,&p);
    290             if (p)
    291             {
    292                 if(!Visit(p->data))
    293                 {
    294                     return ERROR;
    295                 }
    296             }
    297             else
    298             {
    299                 Pop(&S,&p);
    300                 if(!Visit(p->data))
    301                 {
    302                     return ERROR;
    303                 }
    304             }            
    305             while (GetTop(S,&q)&&q&&p==q->rightChild)
    306             {
    307                 Pop(&S,&p);
    308                 if(!Visit(p->data))
    309                 {
    310                     return ERROR;
    311                 }
    312                 GetTop(S,&q);
    313             }
    314         }
    315     }
    316     DestroyStack(&S);
    317     return OK;
    318 }
    319 
    320 //-----------栈的相关操作--------------//
    321 Status InitStack(SqStack *S){
    322     S->base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));
    323     if(!S->base)
    324     {
    325         exit(0);
    326     }
    327     S->top = S->base;
    328     S->stacksize = STACK_INIT_SIZE;
    329     return OK;
    330 }
    331 
    332 Status DestroyStack(SqStack *S){
    333     if(!S)
    334     {
    335         exit(0);
    336     }
    337     free(S->base);
    338     return OK;
    339 }
    340 
    341 Status ClearStack(SqStack *S){
    342     if(!S)
    343     {
    344         return FALSE;
    345     }
    346     S->top = S->base;
    347     return OK;
    348 }
    349 
    350 Status StackEmpty(SqStack S){
    351     if(S.top==S.base)
    352     {
    353         return TRUE;
    354     }
    355     else
    356     {
    357         return FALSE;
    358     }
    359 }
    360 
    361 int StackLength(SqStack S){
    362     return S.stacksize;
    363 }
    364 
    365 Status GetTop(SqStack S,SElemType *e){
    366     if(S.top == S.base)
    367     {
    368         return FALSE;
    369     }
    370     else
    371     {
    372         *e = *(S.top-1);
    373         return OK;
    374     }
    375 }
    376 
    377 Status Push(SqStack *S,SElemType e){
    378     if(S->top-S->base>=S->stacksize)
    379     {
    380         S->base = (SElemType *)realloc(S->base, (S->stacksize + STACKINCREMENT) * sizeof(SElemType));
    381         if(!S->base)
    382         {
    383             exit(0);
    384         }
    385         S->top = S->base+S->stacksize;
    386         S->stacksize += STACKINCREMENT;
    387     }
    388     *S->top++ = e;
    389     return OK;
    390 }
    391 
    392 Status Pop(SqStack *S,SElemType *e){
    393     if(S->top==S->base)
    394     {
    395         return ERROR;
    396     }
    397     *e = *(--S->top);
    398     return OK;
    399 }

    运行示例

  • 相关阅读:
    CentOS7 Python2.7.5升级3.7.1
    kubernets 集群和本地环境联调环境打通工具kt-connect
    Python学习指南
    Python爬虫(十九)_动态HTML介绍
    Python爬虫(十八)_多线程糗事百科案例
    Python爬虫(十七)_糗事百科案例
    Python爬虫(十六)_JSON模块与JsonPath
    python爬虫基本原理及入门
    Python操作数据库
    Python解析xml
  • 原文地址:https://www.cnblogs.com/zhangtingkuo/p/3440692.html
Copyright © 2011-2022 走看看