5.3二叉树的运算

5.3.2二叉树的遍历

（1）前序遍历二叉树的递归定义

若二叉树非空，则依次进行操作：1 访问根结点；2 前序遍历左子树；3 前序遍历右子树。

（2）中序遍历二叉树的递归定义

若二叉树非空，则依次进行操作：1 中序遍历左子树；2 访问根结点；3 中序遍历右子树。

（3）后序遍历二叉树的递归定义

若二叉树非空，则依次进行操作：1 后序遍历左子树；2 后序遍历右子树；3 访问根结点。

C实现

#include <stdio.h>
#include <stdlib.h>

typedef char DataType;

struct node
{
    DataType data;
    struct node * lchild, *rchild;
};
typedef struct node BinTNode;

BinTNode * CreateBinTree();//二叉树的生成
void Preorder(BinTNode * bt);//前序遍历二叉链表算法
void Inorder(BinTNode * bt);//中序遍历二叉链表算法
void Postorder(BinTNode * bt);//后序遍历二叉链表算法

void main()
{
    BinTNode * bt = CreateBinTree();//二叉树的生成

    Preorder(bt);//前序遍历二叉链表算法
    printf("
");

    Inorder(bt);//中序遍历二叉链表算法
    printf("
");

    Postorder(bt);//后序遍历二叉链表算法
    printf("
");

    system("pause");
}

BinTNode * CreateBinTree()
{
    BinTNode * pa = (BinTNode *)malloc(sizeof(BinTNode));
    BinTNode * pb = (BinTNode *)malloc(sizeof(BinTNode));
    BinTNode * pc = (BinTNode *)malloc(sizeof(BinTNode));
    BinTNode * pd = (BinTNode *)malloc(sizeof(BinTNode));
    BinTNode * pe = (BinTNode *)malloc(sizeof(BinTNode));

    pa->data = 'A';
    pb->data = 'B';
    pc->data = 'C';
    pd->data = 'D';
    pe->data = 'E';

    pa->lchild = pb;
    pa->rchild = pc;
    pb->lchild = pb->rchild = NULL;
    pc->lchild = pd;
    pc->rchild = NULL;
    pd->lchild = NULL;
    pd->rchild = pe;
    pe->lchild = pe->rchild = NULL;

    return pa;
}

void Preorder(BinTNode * bt)//前序遍历二叉链表算法
{
    if (bt != NULL)
    {
        printf("%c", bt->data);//访问根结点
        Preorder(bt->lchild);//前序遍历左子树
        Preorder(bt->rchild);//前序遍历右子树
    }
}

void Inorder(BinTNode * bt)//中序遍历二叉链表算法
{
    if (bt != NULL)
    {
        Inorder(bt->lchild);//中序遍历左子树
        printf("%c", bt->data);//访问根结点
        Inorder(bt->rchild);//中序遍历右子树
    }
}

void Postorder(BinTNode * bt)//后序遍历二叉链表算法
{
    if (bt != NULL)
    {
        Postorder(bt->lchild);//后序遍历左子树
        Postorder(bt->rchild);//后序遍历右子树
        printf("%c", bt->data);//访问根结点
    }
}

输出结果

ABCDE
BADEC
BEDCA
请按任意键继续. . .

1递归遍历算法

2非递归遍历算法

C++实现

void Preorder(BinTNode *bt);//前序遍历二叉链表算法
void Inorder(BinTNode *bt);//中序遍历二叉链表算法
void Postorder(BinTNode *bt);//后序遍历二叉链表算法
void Inorder1(BinTNode *bt);//利用栈的非递归中序遍历算法
void Inorder2(BinTNode *bt);//用指针数组来实现二叉树非递归中序遍历算法
int getyenum(BinTNode *bt);//统计叶子结点数量
int BinTreeDepth(BinTNode *bt);//二叉树的深度
void TransLevel(BinTNode *bt);//非递归的按层遍历二叉链表树
int getfather(BinTNode *bt, int num);//查找二叉树的父结点
int getleft(BinTNode *bt, int num);//查找二叉树的某个结点的左兄弟
int findmax(BinTNode *bt);//查找二叉树的最大值
BinTNode *insertnode(BinTNode *bt, int num);//二叉树插入

#include <iostream>
#include <stack>
#include <queue>

typedef struct node
{
    int data;
    struct node *lchild = nullptr, *rchild = nullptr;
}BinTNode;

void Preorder(BinTNode *bt);//前序遍历二叉链表算法
void Inorder(BinTNode *bt);//中序遍历二叉链表算法
void Postorder(BinTNode *bt);//后序遍历二叉链表算法
void Inorder1(BinTNode *bt);//利用栈的非递归中序遍历算法
void Inorder2(BinTNode *bt);//用指针数组来实现二叉树非递归中序遍历算法
int getyenum(BinTNode *bt);//统计叶子结点数量
int BinTreeDepth(BinTNode *bt);//二叉树的深度
void TransLevel(BinTNode *bt);//非递归的按层遍历二叉链表树
int getfather(BinTNode *bt, int num);//查找二叉树的父结点
int getleft(BinTNode *bt, int num);//查找二叉树的某个结点的左兄弟
int findmax(BinTNode *bt);//查找二叉树的最大值
BinTNode *insertnode(BinTNode *bt, int num);//二叉树插入

void main()
{
    BinTNode *root;

    BinTNode s1;
    BinTNode s2;
    BinTNode s3;
    BinTNode s4;
    BinTNode s5;
    BinTNode s6;
    BinTNode s7;

    root = &s1;

    s1.data = 1;
    s2.data = 2;
    s3.data = 3;
    s4.data = 4;
    s5.data = 5;
    s6.data = 6;
    s7.data = 7;

    s1.lchild = &s2;
    s1.rchild = &s3;
    s2.lchild = &s4;
    s2.rchild = &s5;
    s3.lchild = &s6;
    s3.rchild = &s7;

    Preorder(root);//前序遍历二叉链表算法
    std::cout << "
";
    Inorder(root);//中序遍历二叉链表算法
    std::cout << "
";
    Postorder(root);//后序遍历二叉链表算法
    std::cout << "
";

    Inorder1(root);//利用栈的非递归中序遍历算法
    std::cout << "
";

    Inorder2(root);//用指针数组来实现二叉树非递归中序遍历算法
    std::cout << "
";

    std::cout << getyenum(root) << std::endl;//统计叶子结点数量

    std::cout << BinTreeDepth(root) << std::endl;//二叉树的深度

    TransLevel(root);//非递归的按层遍历二叉链表树
    std::cout << "
";

    std::cout << getfather(root, 3) << std::endl;//查找二叉树的父结点

    std::cout << getleft(root, 3) << std::endl;//查找二叉树的某个结点的左兄弟

    std::cout << findmax(root) << std::endl;//查找二叉树的最大值

    insertnode(root, 8);//二叉树插入
    root = &s1;
    Inorder(root);//中序遍历二叉链表算法
    std::cout << "
";
}

void main2()
{
    BinTNode *root;
    BinTNode array[100];

    for (int i = 0; i < 100; i++)
    {
        array[i].data = i;
    }

    for (int i = 0; i < 99 / 2; i++)
    {
        array[i].lchild = &array[2 * i + 1];
        array[i].rchild = &array[2 * i + 2];
    }

    root = &array[0];

    Preorder(root);//前序遍历二叉链表算法
}

void Preorder(BinTNode *bt)//前序遍历二叉链表算法
{
    if (bt != NULL)
    {
        std::cout << bt->data << " ";
        Preorder(bt->lchild);
        Preorder(bt->rchild);
    }
}

void Inorder(BinTNode *bt)//中序遍历二叉链表算法
{
    if (bt != NULL)
    {
        Inorder(bt->lchild);
        std::cout << bt->data << " ";
        Inorder(bt->rchild);
    }
}

void Postorder(BinTNode *bt)//后序遍历二叉链表算法
{
    if (bt != NULL)
    {
        Postorder(bt->lchild);
        Postorder(bt->rchild);
        std::cout << bt->data << " ";
    }
}

void Inorder1(BinTNode *bt)//利用栈的非递归中序遍历算法
{
    std::stack<BinTNode *>S;
    BinTNode *p;
    S.push(bt);

    while (!S.empty())
    {
        while (S.top())
        {
            S.push(S.top()->lchild);//直到左子树空为止
        }

        p = S.top();
        S.pop();//空指针退栈
        
        if (!S.empty())
        {
            std::cout << S.top()->data << " ";//访问根结点

            p = S.top();
            S.pop();
            
            S.push(p->rchild);//右子树进栈
        }
    }
}

void Inorder2(BinTNode *bt)//用指针数组来实现二叉树非递归中序遍历算法
{
    BinTNode *ST[100];//用指针数组模拟栈
    int top = 0;//初始化数组
    ST[top] = bt;

    do
    {
        while (ST[top] != NULL)//根结点及其所有的左结点地址装入数组
        {
            top++;
            ST[top] = ST[top - 1]->lchild;
        }
        top = top - 1;
        if (top >= 0)//判数组中地址是否访问完
        {
            std::cout << ST[top]->data << " ";//访问结点
            ST[top] = ST[top]->rchild;//扫描右子树
        }
    } while (top != -1);
}

int getyenum(BinTNode *bt)//统计叶子结点数量
{
    int left = 0;
    int right = 0;
    if (!bt)
    {
        return 0;
    }
    if (!bt->lchild && !bt->rchild)
    {
        return 1;
    }
    left = getyenum(bt->lchild);
    right = getyenum(bt->rchild);
    return left + right;
}

int BinTreeDepth(BinTNode *bt)//二叉树的深度
{
    int depl, depr;
    if (!bt)
    {
        return 0;
    }
    else
    {
        depl = BinTreeDepth(bt->lchild);
        depr = BinTreeDepth(bt->rchild);
        if (depl > depr)
        {
            return depl + 1;
        }
        else
        {
            return depr + 1;
        }
    }
}

void TransLevel(BinTNode *bt)//按层遍历二叉树，从上到下，从左到右
{
    std::queue<BinTNode *>myqueue;
    if (!bt)//二叉树为空，返回
    {
        return;

    }
    else
    {
        std::cout << bt->data << " ";//输出根结点
        myqueue.push(bt);//根结点指针入队
        while (!myqueue.empty())
        {
            bt = myqueue.front();
            myqueue.pop();//出队列
            if (bt->lchild)
            {
                std::cout << bt->lchild->data << " ";//输出左子树根结点
                myqueue.push(bt->lchild);//左子数入队列
            }
            if (bt->rchild)
            {
                std::cout << bt->rchild->data << " ";//输出右子树根结点
                myqueue.push(bt->rchild);//右子数入队列
            }
        }
    }
}

int getfather(BinTNode *bt, int num)//查找二叉树的父结点
{
    if (!bt)
    {
        return 0;
    }
    if (bt->lchild && bt->lchild->data == num)
    {
        return bt->data;
    }
    if (bt->lchild && bt->rchild->data == num)
    {
        return bt->data;
    }
    getfather(bt->lchild, num);
    getfather(bt->rchild, num);
}

int getleft(BinTNode *bt, int num)//查找二叉树的某个结点的左兄弟
{
    if (!bt)
    {
        return 0;
    }
    if (bt->rchild && bt->rchild->data == num)
    {
        if (bt->lchild)
        {
            return bt->lchild->data;
        }
    }
    getfather(bt->lchild, num);
    getfather(bt->rchild, num);
}

int findmax(BinTNode *bt)//查找二叉树的最大值
{
    BinTNode *ST[100];//用指针数组模拟栈
    int top = 0;//初始化数组
    ST[top] = bt;
    int max = 0;//保存最大值

    do
    {
        while (ST[top] != NULL)//根结点及其所有的左结点地址装入数组
        {
            top++;
            ST[top] = ST[top - 1]->lchild;
        }
        top = top - 1;
        if (top >= 0)//判数组中地址是否访问完
        {
            if (max < ST[top]->data)
            {
                max = ST[top]->data;
            }

            ST[top] = ST[top]->rchild;//扫描右子树
        }
    } while (top != -1);

    return max;
}

BinTNode *insertnode(BinTNode *bt, int num)//二叉树插入
{
    if (!bt)
    {
        BinTNode *pnew = new BinTNode;
        pnew->data = num;
        bt = pnew;
    }
    else if (num < bt->data)
    {
        bt->lchild = insertnode(bt->lchild, num);
    }
    else
    {
        bt->rchild = insertnode(bt->rchild, num);
    }

    return bt;
}

5.3.3二叉树的应用举例

已知二叉树的前序和中序遍历序列或中序和后序遍历序列，可以还原出原始的二叉树。

但是已知二叉树的前序和后序遍历序列，是无法还原出原始的二叉树。

前序遍历，最前面的是根结点。

后序遍历，最后面的是根结点。

应用

树是数据库中数据组织一种重要形式

操作系统子父进程的关系本身就是一棵树（进程树）

面向对象语言中类的继承关系本身就是一棵树

哈夫曼树