c++ stack 遍历_五分钟C语言数据结构 之 二叉树中序遍历?

二叉树中序遍历

二叉树的遍历方式主要由先序遍历、中序遍历和后续遍历，还后就是层次遍历

感受完上篇文章的先序遍历，本节来看看中序遍历

DP问题，欢迎关注

动态规划一篇就够了 全网最详细, 逐步理解, 万字总结 - Johngo的文章 - 知乎 https://zhuanlan.zhihu.com/p/130743652

中序遍历过程

a. 先序遍历其左子树；

b. 访问根节点；

c. 先序遍历其右子树；

然后就是一直递归下去，在访问到节点的时候，可以进行节点的相关处理，比如说简单的访问节点值

下图是一棵二叉树，我们来手动模拟一下中序遍历过程

按照上述中序遍历的过程，得到中序遍历序列：

H 

递归实现

二叉树的中序遍历利用上述的递归思想进行C语言代码实现：

树形结构按照上述树形结构进行初始化

# include <stdio.h>
# include <string.h>
# include <stdlib.h>
# define ElementType char

//结点结构体
typedef struct BinTNode{
    ElementType data; 
    struct BinTNode * left; 
    struct BinTNode * right;
}BinTNode, *BinTree;

// 初始化树形结构
BinTNode * CreateBiTree(BinTNode *T){
    T=(BinTNode*)malloc(sizeof(BinTNode));
    T->data='A';
    T->left=(BinTNode*)malloc(sizeof(BinTNode));
    T->left->data='B';
    T->right=(BinTNode*)malloc(sizeof(BinTNode));
    T->right->data='C';
  
    T->left->left=(BinTNode*)malloc(sizeof(BinTNode));
    T->left->left->data='D';
    T->left->right=(BinTNode*)malloc(sizeof(BinTNode));
    T->left->right->data='E';
    T->left->right->left=NULL;
    T->left->right->right=NULL;  
    T->left->left->left=(BinTNode*)malloc(sizeof(BinTNode));
    T->left->left->left->data='H';
    T->left->left->left->left=NULL;
    T->left->left->left->right=NULL;
    T->left->left->right=(BinTNode*)malloc(sizeof(BinTNode));
    T->left->left->right->data='I';
    T->left->left->right->left=NULL;
    T->left->left->right->right=NULL;
      
    T->right->left=(BinTNode*)malloc(sizeof(BinTNode));
    T->right->left->data='F';
    T->right->left->left=NULL;
    T->right->left->right=NULL;
    T->right->right=(BinTNode*)malloc(sizeof(BinTNode));
    T->right->right->data='G';
    T->right->right->left=NULL;
    T->right->right->right=NULL;

    return T;
}

// 遍历过程中，输出节点值
void printElement(BinTNode * T){
    printf("%c ",T->data);
}

//中序遍历
void InOrderTraverse(BinTNode * T){
    if (T) {
        InOrderTraverse(T->left);  //递归访问左孩子
        printElement(T);            //输出节点值
        InOrderTraverse(T->right); //递归访问右孩子
    }
    // 当节点为空的时候，返回
    return;
}

int main() {
    BinTNode * Tree;
    Tree = CreateBiTree(Tree);  // 初始化树形结构
    printf("中序遍历: ");
    InOrderTraverse(Tree);     // 先序递归进行
    printf("n");               // 最后换行
    return 0;
}

运行结果：

中序遍历

• 当遍历到一个结点时，就压栈，然后继续去遍历它的左子树;
• 当左子树遍历完成后，从栈顶弹出栈顶元素（左子树最后一个元素）并访问它;
• 最后按照当前指正的右孩子继续中序遍历，若没有右孩子，继续弹出栈顶元素。

所以，同样非递归的基本思路：使用堆栈

参照先序遍历非递归，由于在遍历过程中需要保存中间值，将符合遍历的节点优先输出

非递归实现

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define ElementType char
int top = -1;   //定义top栈顶元素下标

// 结点结构体
typedef struct BinTNode{
    ElementType data; 
    struct BinTNode * left; 
    struct BinTNode * right;
}BinTNode, *BinTree;

// 初始化树形结构
BinTNode * CreateBiTree(BinTNode *T) {
    T=(BinTNode*)malloc(sizeof(BinTNode));
    T->data='A';
    T->left=(BinTNode*)malloc(sizeof(BinTNode));
    T->left->data='B';
    T->right=(BinTNode*)malloc(sizeof(BinTNode));
    T->right->data='C';
  
    T->left->left=(BinTNode*)malloc(sizeof(BinTNode));
    T->left->left->data='D';
    T->left->right=(BinTNode*)malloc(sizeof(BinTNode));
    T->left->right->data='E';
    T->left->right->left=NULL;
    T->left->right->right=NULL;  
    T->left->left->left=(BinTNode*)malloc(sizeof(BinTNode));
    T->left->left->left->data='H';
    T->left->left->left->left=NULL;
    T->left->left->left->right=NULL;
    T->left->left->right=(BinTNode*)malloc(sizeof(BinTNode));
    T->left->left->right->data='I';
    T->left->left->right->left=NULL;
    T->left->left->right->right=NULL;
      
    T->right->left=(BinTNode*)malloc(sizeof(BinTNode));
    T->right->left->data='F';
    T->right->left->left=NULL;
    T->right->left->right=NULL;
    T->right->right=(BinTNode*)malloc(sizeof(BinTNode));
    T->right->right->data='G';
    T->right->right->left=NULL;
    T->right->right->right=NULL;

    return T;
}

// 栈 - 进栈push
void push(BinTNode** stack,BinTNode * elem) {
    stack[++top] = elem;
}

//栈 - 弹栈pop
void pop(){
    if (top == -1) {
        return ;
    }
    top--;
}

// 遍历过程中，输出结点值
void printElement(BinTNode* elem) {
    printf("%c ",elem->data);
}

//获取栈顶元素
BinTNode* getTop(BinTNode** stack){
    return stack[top];
}

//非递归遍历 - 左根右
void InOrderTraverse(BinTNode * Tree) {
    BinTNode * stack[20];		// 定义一个栈
    BinTNode * p = Tree;  	// 定义临时指针
    // 1 当前指针指向不为NULL - 说明有右孩子
    // 2 或者栈内不空 - 说明该指针处没有右孩子，继续弹出结点值
    while (p || top!=-1) {
        while (p){
            push(stack, p); 	// 循环将左孩子进栈
            p = p->left;
        }
        if (top!=-1) {
            p=getTop(stack);  //取栈顶元素
            pop();  					//栈顶元素弹栈
            printElement(p);
            p = p->right;
        }
    }
}

int main() {
    BinTNode * Tree;
    Tree = CreateBiTree(Tree);
    printf("看到这样就对了: H D I B E A F C Gn");
    printf("中序遍历:t");
    InOrderTraverse(Tree);
    printf("n");
    return 0;
}

运行结果

看到这样就对了

后续会将更多的数据结构用C语言代码实现，欢迎大家关注!

---

作者：Johngo计算广告，广告收入占到互联网收入的80%以上，一起研究流量变现，欢迎大家的加入