二叉树的遍历（递归法、堆栈法）

最新推荐文章于 2024-08-01 13:01:15 发布

qq_37677421

最新推荐文章于 2024-08-01 13:01:15 发布

阅读量270

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/qq_37677421/article/details/80307970

版权

数据结构专栏收录该内容

13 篇文章 0 订阅

订阅专栏

/* 
    二叉树的遍历  
*/  
  
#include <stdio.h>  
#include <malloc.h>  
#define Ele char  
  
typedef struct BinTree  
{  
    Ele data;  
    struct BinTree * leftChild;  
    struct BinTree * rightChild;  
 }BinTree;  
  
#include "Stack.c"  
#include "LinkQueue.c"  
  
BinTree * NewTree(int level, int nowLevel);  
void TraversalByRecursion(BinTree * T, LinkQueue *LQ, int order) ; //二叉树遍历（递归法）   
void TraversalByStack(BinTree * T, int order) ;  
int main ()  
{  
    BinTree * T = NewTree(10, 1);  
      
    LinkQueue *LQ = NewQueue();   
    printf("\n前序遍历（递归法） ");  
    TraversalByRecursion(T,LQ , 0);  
    printf("\n中序遍历（递归法） ");  
    TraversalByRecursion(T,LQ , 1);  
    printf("\n后序遍历（递归法） ");  
    TraversalByRecursion(T,LQ , 2);  
    printf("\n层次遍历（递归法） ");  
    TraversalByRecursion(T,LQ , 3);  
      
    printf("\n前序遍历（堆栈方法）    ");  
    TraversalByStack(T, 0);  
    printf("\n中序遍历（堆栈方法）    ");  
    TraversalByStack(T, 1);   
    printf("\n层次遍历（堆栈方法）    ");  
    TraversalByStack(T, 3);   
      
    return 0;  
}   
//初始化   
BinTree * NewTree(int level, int nowLevel)  
{  
      
    if(nowLevel > level)  
    {  
        return NULL;  
    }  
    BinTree * T = (BinTree*)malloc(sizeof(BinTree));  
    T->data = nowLevel + 'A';  
    T->leftChild = NewTree(10, nowLevel * 2);  
    T->rightChild = NewTree(10, nowLevel * 2 + 1);  
    return T;  
}  
//遍历(递归方法) order = 0 前序； order = 1 中序； order = 2 后序； oeder = 3 层次   
void TraversalByRecursion(BinTree * T, LinkQueue *LQ,int order)   
{  
    if(order == 0)  
    {   
        printf("%c  ", T->data);  
        if(T->leftChild != NULL)  
            TraversalByRecursion(T->leftChild, LQ, order);  
        if(T->rightChild != NULL)  
            TraversalByRecursion(T->rightChild, LQ, order);  
    }  
    if(order == 1)  
    {  
        if(T->leftChild != NULL)  
            TraversalByRecursion(T->leftChild, LQ, order);  
        printf("%c  ", T->data);  
        if(T->rightChild != NULL)  
            TraversalByRecursion(T->rightChild, LQ, order);  
    }  
    if(order == 2)  
    {  
        if(T->leftChild != NULL)  
            TraversalByRecursion(T->leftChild, LQ, order);  
        if(T->rightChild != NULL)  
            TraversalByRecursion(T->rightChild, LQ, order);  
        printf("%c  ", T->data);  
    }    
    if(order == 3)  
    {  
        //层次遍历：1 输出该节点的值；2 左右子节点入队；3 出队一个节点开始递归   
        printf("%c  ", T->data);//1 输出该节点的值；  
        if(T->leftChild != NULL)  
            PushQueue(LQ, T->leftChild);// 2 左右子节点入队；  
        if(T->rightChild != NULL)  
            PushQueue(LQ, T->rightChild);// 2 左右子节点入队；  
        if(!IsEmptyQueue(LQ))     
            TraversalByRecursion(PopQueue(LQ), LQ, order);//3 出队一个节点开始递归    
    }   
}   
//遍历(堆栈方法) order = 0 前序； order = 1 中序； order = 2 后序； oeder = 3 层次   
void TraversalByStack(BinTree * T, int order)   
{  
      
    BinTree *temp;  
    int rightChild = 0;   
    Stack* S = NewStack();  
    /* 
        中序遍历 
        1   左子树全部压栈；  
        2   出栈 ，打印  
        3   右子树全部入栈  
    */   
    if(order == 1)  
    {  
        while(T != NULL)  
        {  
            //1 左子树全部压栈；   
            while(T != NULL)  
            {  
                Push(S,T);  
                T = T->leftChild;  
            }  
            //2 出栈 ，打印出栈的值  
            do  
            {  
                  
                T = Pop(S);  
                printf("%c  ", T->data);/   
                T = T->rightChild;  
            }  
            while(T == NULL && !IsEmpty(S));  
        }  
          
    }  
    /* 
        前序遍历 
        1   打印 
        2   左子树全部压栈； 
        3   右子树全部入栈  
    */   
    if(order == 0)  
    {  
        while(T != NULL)  
        {  
              
            //1 左子树全部压栈；   
            while(T != NULL)  
            {  
                if(T->leftChild == NULL && T->rightChild == NULL)  
                {  
                    printf("%c  ", T->data);/   
                }  
                Push(S,T);  
                T = T->leftChild;  
            }  
            //2 出栈 ，打印出栈的值  
            do  
            {  
                T = Pop(S);  
                  
                T = T->rightChild;  
            }  
            while(T == NULL && !IsEmpty(S));  
        }  
    }  
      
    /* 
        层次遍历  
        伪算法：  
            根节点入队  
            while(队列不为空)  
                出队一个节点； 
                访问该节点； 
                入队该节点儿子节点；  
    */   
    LinkQueue *LQ = NewQueue();   
    if(order == 3)  
    {  
        PushQueue(LQ, T);//根节点入队   
        while(!IsEmptyQueue(LQ))   
        {  
            T = PopQueue(LQ);//1 出队一个节点   
            printf("%c  ", T->data);//2 打印节点   
            if(T->leftChild != NULL)  
                PushQueue(LQ, T->leftChild);//3 入队儿子节点   
            if(T->rightChild != NULL)  
                PushQueue(LQ, T->rightChild);//3 入队儿子节点   
        }   
    }   
}

Stack.c

/* 
    数据结构-栈（C语言）  
    功能：建栈、出栈、压栈、判断栈是否为空、  
*/  
  
#include <stdio.h>   
#include <malloc.h>  
#define Element BinTree*  
  
  
  
typedef struct _Stack  
{  
    Element data;  
    struct _Stack* next;  
} Stack;  
  
Stack * NewStack();//初始化栈   
int Push(Stack * S, Element value) ;//压栈   
Element Pop(Stack * S);//出栈   
void Traserval(Stack *S);//遍历   
int IsEmpty(Stack * S);//是否为空   
  
//int main()  
//{  
//  int i = 0;  
//  Stack* S = NewStack();  
//  for(i = 0; i < 20; i++)  
//  {  
//      Push(S, i * 3);//压栈   
//  }  
//  Traserval(S);  
//  for(i = 0; i < 25;i++)  
//  {  
//      printf("是否为空 ：%d    ", IsEmpty(S));   
//      printf("出栈： %d\n", Pop(S));  
//  }   
//    
//  return 0;  
//}  
//初始化栈  
Stack * NewStack()  
{  
    Stack* S = (Stack*)malloc(sizeof(Stack));  
    S->next = NULL;  
    S->data = 0;  
    return S;  
 }   
   
//压栈  
int Push(Stack * S, Element value)   
{  
    Stack* temp = NewStack();  
    if(temp == NULL)  
    {  
        return -1;  
    }  
    temp->data = value;  
    temp->next = S->next;  
    S->next = temp;  
    return 1;  
}  
//出栈   
Element Pop(Stack * S)  
{  
    Stack * temp;  
    Element data;  
      
    if(S->next == NULL)  
    {  
        return data;  
    }  
    temp = S->next;  
    data = temp->data;  
    S->next = temp->next;  
    free(temp);  
    return data;  
}  
//是否为空   
int IsEmpty(Stack * S)  
{  
    if(S->next == NULL)  
    {  
        return 1;  
    }  
    return 0;  
}  
  
//遍历  
void Traserval(Stack *S)  
{  
    printf("\n");  
    while(S->next != NULL)   
    {  
        printf("%d\n", S->next->data);  
        S = S->next;  
    }  
}

LinkQueue.c

/* 
    队列(用链式存储结构实现) 
    功能：初始化、入队、出队、遍历、是否为空  
*/  
#include <stdio.h>  
#include <malloc.h>   
#define Ele_3 BinTree*  
  
typedef struct LinkQueue  
{  
    Ele_3 data;  
    struct LinkQueue* next;  
}LinkQueue;  
  
  
LinkQueue* NewQueue();   
void PushQueue(LinkQueue* LQ, Ele_3 data);   
Ele_3 PopQueue(LinkQueue * LQ);  
void TraservalQueue(LinkQueue* LQ);  
int IsEmptyQueue(LinkQueue * LQ);   
//  
//int main()  
//{  
//  int i;  
//  LinkQueue *LQ = NewQueue();   
//  for(i = 0; i < 20; i ++)  
//  {  
//      Push(LQ, i * 4);  
//  }  
//  for(i = 0; i < 25; i ++)  
//  {  
//      printf("是否为空  %d\n",IsEmpty(LQ));  
//      Pop(LQ);  
//      Traserval(LQ);  
//  }   
//  return 0;  
//}  
//初始化   
LinkQueue* NewQueue()  
{  
    LinkQueue* LQ = (LinkQueue*)malloc(sizeof(LinkQueue));  
    LQ->data = 0;  
    LQ->next = NULL;   
}   
//进队   
void PushQueue(LinkQueue* LQ, Ele_3 data)  
{  
    int i;  
    LinkQueue* temp = NewQueue();  
    temp->data = data;  
    while(LQ->next != NULL)  
    {  
        LQ = LQ->next;  
    }  
    LQ->next = temp;  
}  
//出队  
Ele_3 PopQueue(LinkQueue * LQ)  
{  
    LinkQueue * temp;  
    Ele_3 data;  
      
    if(LQ->next == NULL)  
    {  
        return data;  
    }  
    temp = LQ->next;  
    data = temp->data;  
    LQ->next = temp->next;  
    free(temp);  
    return data;      
}   
//是否为空   
int IsEmptyQueue(LinkQueue * LQ)  
{  
    if(LQ->next == NULL)  
    {  
        return 1;  
    }  
    else  
    {  
        return 0;  
    }  
}  
//遍历  
void TraservalQueue(LinkQueue* LQ)  
{  
    printf("\n");  
    while(LQ->next != NULL)   
    {  
        printf("%d\n", LQ->next->data);  
        LQ = LQ->next;  
    }  
}