43-二叉树的递归遍历算法

1. 二叉树的遍历

  二叉树的遍历是按照一定次序访问树中所有节点，并且每个节点仅被访问一次的过程。遍历是二叉树中最基本的运算，也是树中插入、删除、修改、查找和排序运算的基础。

  对于上面这棵二叉树来说，它的遍历方式有三种：先序遍历，中序遍历，后序遍历。

1. 先序遍历：根节点 –> 左子树 –> 右子树（A - B - D - G - C - E - F）
2. 中序遍历：左子树 –> 根节点 –> 右子树（D - G - B - A - E - C - F）
3. 后序遍历：左子树 –> 右子树 –> 根节点（G - D - B - E - F - C - A）

2. 先序遍历的递归算法

先序遍历二叉树的过程：访问根节点，遍历左子树，遍历右子树

void PreOrder(BTNode *b)
{
    //当树不为空时
    if (b!=NULL)
    {
        //访问根节点
        printf("%c ",b->data);
        //遍历左子树
        PreOrder(b->lchild);
        //遍历右子树
        PreOrder(b->rchild);
    }
}

我们来看一下二叉树的先序遍历的递归算法调用过程：

根据先序遍历的递归算法来看：
1. PreOrder（A）先访问根节点
2. PreOrder（B）遍历左子树
3. PreOrder（C）遍历右子树

3. 中序和后序遍历的递归算法

中序遍历二叉树的过程：遍历左子树，访问根节点，遍历右子树

后序遍历二叉树的过程：遍历左子树，遍历右子树，访问根节点

//中序遍历的递归算法
void InOrder(BTNode *b)
{
    if (b!=NULL)
    {
        InOrder(b->lchild);
        printf("%c ",b->data);
        InOrder(b->rchild);
    }
}


//后序遍历的递归算法
void PostOrder(BTNode *b)
{
    if (b!=NULL)
    {
        PostOrder(b->lchild);
        PostOrder(b->rchild);
        printf("%c ",b->data);
    }
}

4. 测试代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


//二叉树结点
typedef struct BINARYNODE{
    char data;
    struct BINARYNODE* lchild;
    struct BINARYNODE* rchild;
}BinaryNode;


//先序遍历的递归算法
void PreOrder(BinaryNode *node)
{
    if(node != NULL)
    {
        printf("%c" , node->data);
        PreOrder(node->lchild);
        PreOrder(node->rchild);
    }
}

//中序遍历的递归算法
void InOrder(BinaryNode *node)
{
    if(node != NULL)
    {
        InOrder(node->lchild);
        printf("%c" , node->data);
        InOrder(node->rchild);
    }
}


//后序遍历的递归算法
void PostOrder(BinaryNode *node)
{
    if(node != NULL)
    {
        PostOrder(node->lchild);
        PostOrder(node->rchild);
        printf("%c" , node->data);
    }
}


void Create_BinaryTree()
{
    //创建节点
    BinaryNode node1 = { 'A', NULL, NULL };
    BinaryNode node2 = { 'B', NULL, NULL };
    BinaryNode node3 = { 'C', NULL, NULL };
    BinaryNode node4 = { 'D', NULL, NULL };
    BinaryNode node5 = { 'E', NULL, NULL };
    BinaryNode node6 = { 'F', NULL, NULL };
    BinaryNode node7 = { 'G', NULL, NULL };

    //建立二叉树
    node1.lchild = &node2;
    node1.rchild = &node3;
    node2.lchild = &node4;
    node3.lchild = &node5;
    node3.rchild = &node6;
    node4.rchild = &node7;

    printf("先序遍历：");
    //先序遍历
    PreOrder(&node1);
    printf("\n");

    printf("中序遍历：");
    //中序遍历
    InOrder(&node1);
    printf("\n");

    printf("后序遍历：");
    //后序遍历
    PostOrder(&node1);
    printf("\n");
}

int main(void)
{
    Create_BinaryTree();
    return 0;
}

测试结果：