数据结构——二叉树的遍历

　　二叉树的遍历是指通过一定顺序访问二叉树的所有结点。遍历方法一般有四种：先序遍历、中序遍历、后序遍历及层次遍历。

一、先序遍历

　　对先序遍历来说，总是先访问根结点 root，然后才去访问左子树和右子树，因此先序遍历的遍历顺序是根结点 -> 左子树 -> 右子树。代码如下：

// 先序遍历
void preorder(node* root) {
    if(root == NULL) {
        return;        // 空树，递归边界 
    }
    printf("%d
", root->data);        // 访问该结点
    preorder(root->lchild);            // 访问左子树 
    preorder(root->rchild);            // 访问右子树  
} 

　　对一棵二叉树的先序遍历序列，序列的第一个一定是根结点。　　

二、中序遍历

　　对中序遍历来说，总是先访问左子树，再访问根结点，最后访问右子树，因此中序遍历的遍历顺序是左子树 -> 根结点 -> 右子树。代码如下：

// 中序遍历
void inorder(node* root) {
    if(root == NULL) {
        return;        // 空树，递归边界 
    }
    inorder(root->lchild);            // 访问左子树 
    printf("%d
", root->data);        // 访问该结点
    inorder(root->rchild);            // 访问右子树  
} 

　　由于中序遍历总是把根结点放在左子树和右子树之间，因此只要知道根结点，就可以通过根结点在中序遍历序列中的位置区分出左子树和右子树。

三、后序遍历

　　对后序遍历来说，总是先访问左子树，再访问右子树，最后才访问根结点，因此后序遍历的遍历顺序是左子树 -> 右子树 -> 根结点。代码如下：

// 后序遍历
void postorder(node* root) {
    if(root == NULL) {
        return;        // 空树，递归边界 
    }
    postorder(root->lchild);            // 访问左子树 
    postorder(root->rchild);            // 访问右子树
    printf("%d
", root->data);            // 访问该结点  
} 

四、一个重要问题

　　给定一棵二叉树的先序遍历序列和中序遍历序列，重建这棵二叉树。

　　假设在递归过程中，当前先序序列的区间为 [preL, preR] ，中序序列的区间为 [inL, inR] ，且 in_k = pre₁ ，那么左子树的结点个数为 numLeft = k - inL。这样左子树的先序序列区间就是 [preL+1, pre+numLeft]，左子树的中序序列区间是 [inL, k-1]；右子树的先序序列区间是 [preL+numLeft+1, preR]，右子树的中序序列区间是 [k+1, inR]。

　　当先序序列的长度小于等于 0 时，当前二叉树就不存在了，这个条件可以作为递归边界。代码如下：

int pre[maxn]={1, 2, 4, 5, 3, 6}, in[maxn]={4, 2, 5, 1, 3, 6};    // 储存先序、中序序列
// 当前先序序列 [preL, preR]，中序序列 [inL, inR]，返回根结点地址
node* create1(int preL, int preR, int inL, int inR) {
    if(preL > preR) {
        return NULL;    // 先序序列长度小于等于0，递归边界 
    }
    node* root = (node*)malloc(sizeof(node));
    root->data = pre[preL];        // 新结点的数据域为根结点的值
    int k;
    for(k=inL; k<=inR; ++k) {
        if(in[k] == pre[preL]) {    // 在中序序列中找到根结点 
            break;
        }
    } 
    int numLeft = k - inL;    // 左子树结点个数
    
    // 左子树的先序序列区间是 [preL+1, pre+numLeft]，中序序列区间是 [inL, k-1]
    root->lchild = create1(preL+1, preL+numLeft, inL, k-1);
    // 右子树的先序序列区间是 [preL+numLeft+1, preR]，中序序列区间是 [k+1, inR]
    root->rchild = create1(preL+numLeft+1, preR, k+1, inR);
    
    return root; 
} 

　　完整 C 代码如下：

/*
    二叉树 
*/

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <stdbool.h>

#define typename int
#define maxn 20
// 二叉树结构定义 
typedef struct _node {
    typename data;        // 数据域
    struct _node* lchild;        // 指向左子树的根结点
    struct _node* rchild;        // 指向右子树的根结点 
} node; 

// 生成一个新节点，v为数据 
node* newNode(typename v) {
    node* Node = (node*)malloc(sizeof(node));
    Node->data = v;
    // 初始状态下没有左右子树 
    Node->lchild = Node->rchild = NULL;
    return Node;
} 

// 在根结点为root的二叉树查找所有数据域为x的结点并修改为newdata 
void search(node* root, typename x, typename newdata) {
    if(root == NULL) {
        return;        // 空树 
    }
    if(root->data == x) {    // 查到 x 
        root->data = newdata;    // 修改 
    }
    search(root->lchild, x, newdata);    // 遍历左子树
    search(root->rchild, x, newdata);    // 遍历右子树      
} 

// 在以*root为根结点的二叉树插入一个新节点 
void insert(node** root, typename x) {
    if((*root) == NULL) {        // 找到插入位置 
        (*root) = newNode(x);
        return; 
    }
    if(x < (*root)->data) {        // 往左子树插入 
        insert(&((*root)->lchild), x);
    } else {                    // 往右子树插入 
        insert(&((*root)->rchild), x);
    }
}

// 二叉树的建立 
node* create(typename data[], int n) {
    node* root = NULL;        // 新建空根结点 root 
    int i;
    for(i=0; i<n; ++i) {    // 将 data 中的数据插入二叉树 
        insert(&root, data[i]);
    } 
    return root;            // 返回根结点 
} 

// 先序遍历
void preorder(node* root) {
    if(root == NULL) {
        return;        // 空树，递归边界 
    }
    printf("%d
", root->data);        // 访问该结点
    preorder(root->lchild);            // 访问左子树 
    preorder(root->rchild);            // 访问右子树  
} 

// 中序遍历
void inorder(node* root) {
    if(root == NULL) {
        return;        // 空树，递归边界 
    }
    inorder(root->lchild);            // 访问左子树 
    printf("%d
", root->data);        // 访问该结点
    inorder(root->rchild);            // 访问右子树  
} 

// 后序遍历
void postorder(node* root) {
    if(root == NULL) {
        return;        // 空树，递归边界 
    }
    postorder(root->lchild);            // 访问左子树 
    postorder(root->rchild);            // 访问右子树
    printf("%d
", root->data);            // 访问该结点  
} 

int pre[maxn]={1, 2, 4, 5, 3, 6}, in[maxn]={4, 2, 5, 1, 3, 6};    // 储存先序、中序序列
// 当前先序序列 [preL, preR]，中序序列 [inL, inR]，返回根结点地址
node* create1(int preL, int preR, int inL, int inR) {
    if(preL > preR) {
        return NULL;    // 先序序列长度小于等于0，递归边界 
    }
    node* root = (node*)malloc(sizeof(node));
    root->data = pre[preL];        // 新结点的数据域为根结点的值
    int k;
    for(k=inL; k<=inR; ++k) {
        if(in[k] == pre[preL]) {    // 在中序序列中找到根结点 
            break;
        }
    } 
    int numLeft = k - inL;    // 左子树结点个数
    
    // 左子树的先序序列区间是 [preL+1, pre+numLeft]，中序序列区间是 [inL, k-1]
    root->lchild = create1(preL+1, preL+numLeft, inL, k-1);
    // 右子树的先序序列区间是 [preL+numLeft+1, preR]，中序序列区间是 [k+1, inR]
    root->rchild = create1(preL+numLeft+1, preR, k+1, inR);
    
    return root; 
} 

/*// 输出二叉树，先序 
void print(node* root) {
    if(root == NULL) {
        return;
    }
    printf("%d ", root->data);
    print(root->lchild);
    print(root->rchild);
}*/

int main() {
    /*int data[5] = {1, 2, 3, 4, 5};
    node* tree = create(data, 5);    // 创建二叉树 
    print(tree);                    // 输出二叉树 */
    
    node* tree = create1(0, 5, 0, 5);
    postorder(tree);
    
    return 0;
}