- 非遞迴實現程式碼：

#include<stdio.h>
#include<stdlib.h>
#include"data_structure.h"

//建立一棵二叉樹
BTree create_tree()
{
    BTree pA = (BTree)malloc(sizeof(BTNode));
    BTree pB = (BTree)malloc(sizeof(BTNode));
    BTree pD = (BTree)malloc(sizeof(BTNode));
    BTree pE = (BTree)malloc(sizeof(BTNode));
    BTree pC =
 
 (BTree)malloc(sizeof(BTNode));
    BTree pF = (BTree)malloc(sizeof(BTNode));

    pA->data = 'A';
    pB->data = 'B';
    pD->data = 'D';
    pE->data = 'E';
    pC->data = 'C';
    pF->data = 'F';

    pA->pLchild = pB;
    pA->pRchild = pC;
    pB->pLchild = pD;
    pB->
 
pRchild = pE;
    pD->pLchild = pD->pRchild = NULL;
    pE->pLchild = pE->pRchild = NULL;
    pC->pLchild = pF;
    pC->pRchild = NULL;
    pF->pLchild = pF->pRchild = NULL;   

    return pA;
}

/*
前序遍歷的非遞迴實現
*/
void pre_traverse(BTree pTree)
{
    PSTACK stack = create_stack();  //建立一個空棧
 

    BTree node_pop;                 //用來儲存出棧節點
    BTree pCur = pTree;             //定義用來指向當前訪問的節點的指標

    //直到當前節點pCur為NULL且棧空時，迴圈結束
    while(pCur || !is_empty(stack))
    {
        //從根節點開始，輸出當前節點，並將其入棧，
        //同時置其左孩子為當前節點，直至其沒有左孩子，及當前節點為NULL
        printf("%c ", pCur->data);
        push_stack(stack,pCur);
        pCur = pCur->pLchild;
        //如果當前節點pCur為NULL且棧不空，則將棧頂節點出棧，
        //同時置其右孩子為當前節點,迴圈判斷，直至pCur不為空
        while(!pCur && !is_empty(stack))
        {
            pCur = getTop(stack);
            pop_stack(stack,&node_pop);
            pCur = pCur->pRchild;           
        }
    }
}

/*
中序遍歷的非遞迴實現
*/
void in_traverse(BTree pTree)
{
    PSTACK stack = create_stack();  //建立一個空棧
    BTree node_pop;                 //用來儲存出棧節點
    BTree pCur = pTree;             //定義指向當前訪問的節點的指標

    //直到當前節點pCur為NULL且棧空時，迴圈結束
    while(pCur || !is_empty(stack))
    {
        if(pCur->pLchild)
        {
            //如果pCur的左孩子不為空，則將其入棧，並置其左孩子為當前節點
            push_stack(stack,pCur);
            pCur = pCur->pLchild;
        }
        else
        {
            //如果pCur的左孩子為空，則輸出pCur節點，並將其右孩子設為當前節點，看其是否為空
            printf("%c ", pCur->data);
            pCur = pCur->pRchild;
            //如果為空，且棧不空，則將棧頂節點出棧，並輸出該節點，
            //同時將它的右孩子設為當前節點，繼續判斷，直到當前節點不為空
            while(!pCur && !is_empty(stack))
            {
                pCur = getTop(stack);
                printf("%c ",pCur->data);   
                pop_stack(stack,&node_pop);
                pCur = pCur->pRchild;
            }
        }
    }
}

/*
後序遍歷的非遞迴實現
*/
void beh_traverse(BTree pTree)
{
    PSTACK stack = create_stack();  //建立一個空棧
    BTree node_pop;          //用來儲存出棧的節點
    BTree pCur;              //定義指標，指向當前節點
    BTree pPre = NULL;       //定義指標，指向上一各訪問的節點

    //先將樹的根節點入棧
    push_stack(stack,pTree);  
    //直到棧空時，結束迴圈
    while(!is_empty(stack))
    {
        pCur = getTop(stack);   //當前節點置為棧頂節點
        if((pCur->pLchild==NULL && pCur->pRchild==NULL) || 
            (pPre!=NULL && (pCur->pLchild==pPre || pCur->pRchild==pPre)))
        {
            //如果當前節點沒有左右孩子，或者有左孩子或有孩子，但已經被訪問輸出，
            //則直接輸出該節點，將其出棧，將其設為上一個訪問的節點
            printf("%c ", pCur->data);
            pop_stack(stack,&node_pop);
            pPre = pCur;
        }
        else
        {
            //如果不滿足上面兩種情況,則將其右孩子左孩子依次入棧
            if(pCur->pRchild != NULL)
                push_stack(stack,pCur->pRchild);
            if(pCur->pLchild != NULL)
                push_stack(stack,pCur->pLchild);
        }
    }
}

- 遞迴實現程式碼：

#include<stdio.h>
#include<stdlib.h>
typedef struct BTNode
{
    char data;
    struct BTNode *pLchild;
    struct BTNode *pRchild;
}BTNode, *BTree;

BTree create_tree();
void pre_traverse(BTree);
void in_traverse(BTree);
void beh_traverse(BTree);

int main()
{
    BTree pTree = create_tree();

    printf("遞迴實現前序遍歷結果：");
    pre_traverse(pTree);
    printf("\n");

    printf("遞迴實現中序遍歷結果：");
    in_traverse(pTree);
    printf("\n");

    printf("遞迴實現後序遍歷結果：");
    beh_traverse(pTree);
    printf("\n");

    return 0;
}

BTree create_tree()
{
    BTree pA = (BTree)malloc(sizeof(BTNode));
    BTree pB = (BTree)malloc(sizeof(BTNode));
    BTree pD = (BTree)malloc(sizeof(BTNode));
    BTree pE = (BTree)malloc(sizeof(BTNode));
    BTree pC = (BTree)malloc(sizeof(BTNode));
    BTree pF = (BTree)malloc(sizeof(BTNode));

    pA->data = 'A';
    pB->data = 'B';
    pD->data = 'D';
    pE->data = 'E';
    pC->data = 'C';
    pF->data = 'F';

    pA->pLchild = pB;
    pA->pRchild = pC;
    pB->pLchild = pD;
    pB->pRchild = pE;
    pD->pLchild = pD->pRchild = NULL;
    pE->pLchild = pE->pRchild = NULL;
    pC->pLchild = pF;
    pC->pRchild = NULL;
    pF->pLchild = pF->pRchild = NULL;   

    return pA;
}

/*
前序遍歷的遞迴實現
*/
void pre_traverse(BTree pTree)
{
    if(pTree)
    {
        printf("%c ",pTree->data);
        if(pTree->pLchild)
            pre_traverse(pTree->pLchild);
        if(pTree->pRchild)
            pre_traverse(pTree->pRchild);   
    }
}

/*
中序遍歷的遞迴實現
*/
void in_traverse(BTree pTree)
{
    if(pTree)
    {
        if(pTree->pLchild)
            in_traverse(pTree->pLchild);
        printf("%c ",pTree->data);
        if(pTree->pRchild)
            in_traverse(pTree->pRchild);    
    }
}

/*
後序遍歷的遞迴實現
*/
void beh_traverse(BTree pTree)
{
    if(pTree)
    {
        if(pTree->pLchild)
            beh_traverse(pTree->pLchild);
        if(pTree->pRchild)
            beh_traverse(pTree->pRchild);   
        printf("%c ",pTree->data);
    }
}