二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

• 树中节点数目在范围 [0, 100] 内
• -100 <= Node.val <= 100

思路一：递归思想

中序：左根右的顺序

题目需要返回的是数组，returnSize是存储数组大小的指针，我们需要初始化一个数组来存储结果，此时代码里的a就是我们建立的一个大小为200的数组，让returnSize初始化为0,然后进行递归遍历，递归遍历的函数内包含根结点，存储结点内容的数组，及数组大小，i来记录变化的数组大小，先中序递归遍历左子树，将根结点值赋给数组，再中序递归遍历右子树，最终返回数组。

代码：

void inorder(struct TreeNode*root,int *a,int *returnSize){
    int i;
    if(root!=NULL){
        inorder(root->left,a,returnSize);
        i=(*returnSize)++;
         a[i]=root->val;
        inorder(root->right,a,returnSize);
    }
}
int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    int *a=(int*)malloc(sizeof(int)*200);
    *returnSize=0;
    inorder(root,a,returnSize);
    return a;
}

思路二：迭代

代码：相当于是栈的操作。

与思路一差不多，不同的是我们建立了一个数组来模拟栈的入栈和出栈操作。

void inorder(struct TreeNode* root,int *a,int *returnSize){
    struct TreeNode* *stack=malloc(sizeof(struct TreeNode*)*200);
    int top=0;
    struct TreeNode *p;
    p=root;
    while(p!=NULL||top!=0){
        if(p!=NULL){
            stack[top++]=p;
            p=p->left;
        }
        else{
            p=stack[--top];
            a[(*returnSize)++]=p->val;
            p=p->right;
        }
    }
}
int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    int *a=(int *)malloc(sizeof(int)*100);
    *returnSize=0;
    inorder(root,a,returnSize);
    return a;
}

思路三：

（非递归遍历）用到栈

这里用到了栈的思想，我们定义一个栈，初始化栈，当我们的结点或栈不为空时，如果结点不为空，我们让它进栈，指向它的左孩子。循环结束说明此时左孩子根结点已没有，中序遍历左根右的思想，我们就让它出栈，访问当前结点的值，再指向右孩子。

例如：

一棵树为：ABC##DE#G##F### 

中序遍历为：CBEGDFA

p等于结点，结点为A，节点不为空，则A进栈，此时p指向A的左孩子结点B，p不为空，则B进栈，

此时p指向B的左孩子C，p不为空，则C进栈，p指向C的左孩子，左孩子为空，则p为空，退出循环，此时栈内有三个元素A,B,C，我们将其出栈并输出该结点，则为C，p指向C的右孩子，右孩子为空，我们继续将栈内元素输出，则输出结点B，此时p指向B的右孩子，右孩子为D，不为空，进入循环，则D进栈，p指向D的左孩子，D的左孩子为E，p不为空，则E进栈，此时，p指向E的左孩子，E的左孩子为空，则退出循环，将E的根输出，p指向E的右孩子为G，此时根结点不为空，则G进栈，p指向G的左孩子为空，退出循环，然后将其出栈。依次得到中序遍历结果。

中序代码：

void Inorder(BiTree root){
    SeqStack *s;
    BiTree p;
    s=Init();
    p=root;
    while(p!=NULL||!IsEmpty(s)){
    	while(p!=NULL){
    		Push(s,p);
    		p=p->Lchild;
		}
		if(!IsEmpty(s)){
			Pop(s,&p);
			printf("%c",p->data);
			p=p->Rchild;
		}
	}
}

整体代码：

#include<stdio.h>
#include<stdlib.h>
# define max 100
typedef char DataType;
typedef struct Node{
    DataType data;
    struct Node *Lchild;
    struct Node *Rchild;
}BiTNode,*BiTree;
typedef struct{
	BiTree data[max];
	int top;
}SeqStack;
SeqStack * Init(){
	SeqStack *s;
	s=(SeqStack*)malloc(sizeof(SeqStack));
	s->top=-1;
	return s;
}
int IsEmpty(SeqStack *s){
	if(s->top==-1){
		return 1;
	}
	else{
		return 0;
	}
}
void Push(SeqStack *s,BiTree x){
	if(s->top==max-1){
		return;
	}
	else{
		s->top++;
		s->data[s->top]=x;
	}
}
void Pop(SeqStack *s,BiTree *x){
	if(IsEmpty(s)){
		return;
	}
	else{
		*x=s->data[s->top];
		s->top--;
	}
}
BiTree Create(){
    BiTree bt;
    char ch;
    ch=getchar();
    if(ch=='#'){
        return NULL;
    }
    else{
        bt=(BiTree)malloc(sizeof(BiTNode));
        bt->data=ch;
        bt->Lchild=Create();
        bt->Rchild=Create();
        return bt;
    }
}
void Inorder(BiTree root){
    SeqStack *s;
    BiTree p;
    s=Init();
    p=root;
    while(p!=NULL||!IsEmpty(s)){
    	while(p!=NULL){
    		Push(s,p);
    		p=p->Lchild;
		}
		if(!IsEmpty(s)){
			Pop(s,&p);
			printf("%c",p->data);
			p=p->Rchild;
		}
	}
}
void PrintTree(BiTree bt,int h)
{
    if(bt == NULL)
        return ;
    PrintTree(bt->Rchild,h+1);
    for(int i=0;i<h;i++)
        printf("  ");
    printf("%c\n",bt->data);
    PrintTree(bt->Lchild,h+1);
}
int main(){
    BiTree root;
    root=Create();
    Inorder(root);
    printf("\n");
    PrintTree(root,0); 
}