数据结构之树：中序遍历二叉树（C & Python）

二叉树中序遍历的实现思想是：

1. 访问当前节点的左子树
2. 访问根节点
3. 访问当前节点的右子树

以上图为例，采用中序遍历的思想遍历该二叉树的过程为：

1. 访问该二叉树的根节点，找到 1
2. 遍历节点 1 的左子树，找到节点 2
3. 遍历节点 2 的左子树，找到节点 4
4. 由于节点 4 无左孩子，因此找到节点 4，并遍历节点 4 的右子树
5. 由于节点 4 无右子树，因此节点 2 的左子树遍历完成，访问节点 2
6. 遍历节点 2 的右子树，找到节点 5
7. 由于节点 5 无左子树，因此访问节点 5 ，又因为节点 5 没有右子树，因此节点 1 的左子树遍历完成，访问节点 1 ，并遍历节点 1 的右子树，找到节点 3
8. 遍历节点 3 的左子树，找到节点 6
9. 由于节点 6 无左子树，因此访问节点 6，又因为该节点无右子树，因此节点 3 的左子树遍历完成，开始访问节点 3 ，并遍历节点 3 的右子树，找到节点 7
10. 由于节点 7 无左子树，因此访问节点 7，又因为该节点无右子树，因此节点 1 的右子树遍历完成，即整棵树遍历完成

 因此，上图中二叉树采用中序遍历得到的序列为：4 2 5 1 6 3 7

1. 根结点入栈
2. 栈顶结点设为当前结点，找到结点的左孩子，左孩子为空则进入操作4，左孩子不为空则将其入栈
3. 重复操作2
4. 当前结点左孩子为空，访问该结点并将其出栈
5. 结点右孩子不为空则进入操作6，为空则代表结点的父结点的左子树已遍历，将父结点的左孩子置空，代表已遍历父结点左子树
6. 将结点右孩子入栈

代码：

'''C

#include 
#include 
#include 

#define STACK_INITSIZE 100
#define STACK_INCREMENT 10

//******************************************************************
//                         创建树
//******************************************************************

//树结点结构体
typedef struct node
{
    int data;
    struct node *lchild, *rchild;
}BiNode, *BiTree;

//创建一个简单的树，返回树的根结点指针
BiTree createBiTree()
{
    BiTree T=(BiNode *)malloc(sizeof(BiNode));
    T->data=1;
    T->lchild=(BiNode *)malloc(sizeof(BiNode));
    T->rchild=(BiNode *)malloc(sizeof(BiNode)); 
    T->lchild->data=2;
    T->lchild->lchild=(BiNode *)malloc(sizeof(BiNode));
    T->lchild->rchild=(BiNode *)malloc(sizeof(BiNode));
    T->lchild->rchild->data=5;
    T->lchild->rchild->lchild=NULL;
    T->lchild->rchild->rchild=NULL;
    T->rchild->data=3;
    T->rchild->lchild=(BiNode *)malloc(sizeof(BiNode));
    T->rchild->lchild->data=6;
    T->rchild->lchild->lchild=NULL;
    T->rchild->lchild->rchild=NULL;
    T->rchild->rchild=(BiNode *)malloc(sizeof(BiNode));
    T->rchild->rchild->data=7;
    T->rchild->rchild->lchild=NULL;
    T->rchild->rchild->rchild=NULL;
    T->lchild->lchild->data=4;
    T->lchild->lchild->lchild=NULL;
    T->lchild->lchild->rchild=NULL;
    return T;
}


//****************************************************************
//                            创建栈
//****************************************************************

//栈结构体
typedef struct 
{
    BiNode *base;
    BiNode *top;
    int size;
}BiStack;

//栈初始化
BiStack stackInit()
{
    BiStack s;
    s.base = (BiNode *)malloc(sizeof(BiNode)*STACK_INITSIZE);
    s.top = s.base;
    s.size =STACK_INITSIZE;
    return s;
}

//入栈
void push(BiStack *s, BiNode e)
{
    if(s->top - s->base >= s->size)
    {
        s->size += STACK_INCREMENT;
        s->base = (BiNode *)realloc(s->base, sizeof(BiNode)*s->size);
    }
    *s->top = e;
    s->top++;
}

//出栈
BiNode pop(BiStack *s)
{
    BiNode temp;
    s->top--;
    temp = *s->top;
    return temp;
}

//得到栈顶元素，但不出栈
BiNode getTop(BiStack s)
{
    BiNode temp;
    s.top--;
    temp = *s.top;
    return temp;
}



//*********************************************************************
//                     使用栈结构中序遍历二叉树
//*********************************************************************

int time = 0;    //记录访问结点次数
//访问结点
void visitNode(BiNode *root)
{
    time++;
    printf("第%d次访问的结点是：%dn", time, root->data);
}

int cnt = 0;     //记录栈变化次数
int stack[20][20];     //记录栈每次改变时栈中结点的数据
//遍历栈中结点
void traverseStack(BiStack s)
{ 
    int i = 0;
    while(s.base != s.top)
    {
        stack[cnt][i] = s.base->data;
        i++;
        s.base++;
    }
    stack[cnt][i] = 0xFFFFFFFF;
    cnt++;
}

//中序遍历二叉树
void inorderTraverse(BiTree T)
{  
    BiStack bs = stackInit();
    traverseStack(bs);
    BiNode root = *T;  
    BiNode *temp = NULL;
    push(&bs, root);      //根结点入栈
    traverseStack(bs);
    while(bs.top != bs.base)      //栈空表示遍历结束
    {
        root = getTop(bs);
        temp = root.lchild;       //先访问左孩子
        while(temp != NULL)       //左孩子不为空
        {
            //左孩子入栈
            root = *temp;
            temp = root.lchild;
            push(&bs, root);
            traverseStack(bs);
            
        }
        //找到左孩子为空的结点，访问该结点并出栈
        visitNode(&root);
        pop(&bs);
        traverseStack(bs);

        temp = root.rchild;          
        if(temp == NULL)          //结点的右孩子为空，代表结点的父结点的左子树已遍历      
        {
            if(bs.top != bs.base)
            {
                root = pop(&bs);
                root.lchild = NULL;           
                push(&bs, root);            
            }        
        }                         //结点的右孩子不为空，将右孩子入栈
        else
        {
            root = *temp;      
            push(&bs, root);
            traverseStack(bs);  
        }
    }
}



//************************************************************************************
//                                     主函数
//************************************************************************************

void main()
{
    BiTree Tree = createBiTree();
    printf("n二叉树中序遍历结果如下n");
    inorderTraverse(Tree);

    printf("nn栈中结点变化情况如下n");
    for(int i = 0; i < cnt; i++)
    {
        printf("栈中的结点有：");
        int j = 0;
        while(stack[i][j] != 0xFFFFFFFF)
        {
            printf("%d ", stack[i][j]);
            j++;
        }
        printf("n");
    }
    printf("nn");
    system("date /T");
    system("TIME /T");
    system("pause");
    exit(0);  
}

运行结果：

 代码：

'''Python

import datetime
import time

##################################################################################
#                                     二叉树
##################################################################################

#树结点类      
class BiNode():
    #创建结点，左右孩子为空
    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None
    
    #创建左右孩子结点    
    def creat(self, data1=0xFFFFFFFF, data2=0xFFFFFFFF):
        if data1 != 0xFFFFFFFF:
            self.lchild = BiNode(data1)
        if data2 != 0xFFFFFFFF:
            self.rchild = BiNode(data2)
            
        
#创建一棵简单的二叉树
def creatTree():
    T = BiNode(1)
    T.creat(2, 3)
    T.lchild.creat(4, 5)
    T.rchild.creat(6, 7)
    return T
    

#############################################################################################
#                                       栈
#############################################################################################

#栈类
class Stack():
    def __init__(self):
        self.bs = []

    def push(self, e):
        self.bs.append(e)
        
    def pop(self):
        return self.bs.pop()

    def getTop(self):
        return self.bs[-1]


####################################################################################
#                         使用栈结构中序遍历二叉树
####################################################################################

time = 0              #记录访问结点次数
#访问结点的操作 
def visitNode(node):
    global time       #将time设为全局变量
    time += 1
    print("第{}次访问的结点是：{}".format(time, node.data))

stackList = []        #记录栈中元素，列表的每个元素也为列表
#遍历栈，栈中结点的数据存储在stackList中
def traverseStack(treeStack):
    global stackList
    temp = []
    for i in range(len(treeStack.bs)):
        temp.append(treeStack.bs[i].data)
    stackList.append(temp)

#中序遍历二叉树        
def inorderTraverse(T):
    treeStack = Stack()
    traverseStack(treeStack)
    treeStack.push(T)                #根结点入栈
    traverseStack(treeStack)
    while treeStack.bs != []:        #栈空代表遍历结束
        root = treeStack.getTop()
        temp = root.lchild
        while temp != None:
            #左孩子入栈          
            treeStack.push(temp)
            traverseStack(treeStack)
            root = temp
            temp = root.lchild
        #找到左孩子为空的结点，访问该结点并出栈
        visitNode(root)
        treeStack.pop()
        traverseStack(treeStack); 
                 
        temp = root.rchild            #后访问右孩子
        if temp == None:              #结点的右孩子为空，代表结点的父结点的左子树已遍历 
            if treeStack.bs != []:
                root = treeStack.pop()
                root.lchild = None
                treeStack.push(root)
        else:                         #结点的右孩子不为空，将右孩子入栈
            treeStack.push(temp)
            traverseStack(treeStack) 

        
        
if __name__ == '__main__':
    T = creatTree()
    print("n二叉树中序遍历结果如下")
    inorderTraverse(T)
    print("n栈中结点变化情况如下")
    for i in range(len(stackList)):
        print("栈中的结点有：{}".format(stackList[i]))
    print("nn")
    datetime = datetime.datetime.now()
    print(datetime.strftime("%Y-%m-%dn%H:%M:%S"))

运行结果：