数据结构——二叉树

树的一些基本术语：（针对我个人觉得要必要列出来的

• 结点的度：结点拥有的子树数。
• 树的度：树内各结点度的最大值。
• 非终端结点：度不为0的结点称为非终端结点或分支结点。除根结点外，非终端结点也称为内部结点。
• 层次：根为第一层，不是第零层。
• 树的深度：树中结点的最大层次，深度也称为高度。
• 森林：是m（m>=0）棵互不相交的树的集合。对树中每个结点而言，其子树的集合即为森林。对森林加上一个根，森林即成为树；删去根，树即成为森林。

二叉树的一些性质：

1. 在二叉树的第i层上至多有2^i-1个结点（i>=1）。
2. 深度为k的二叉树至多有2^k-1个结点（k>=1）。
3. 在任意一棵二叉树中，若终端结点（叶子结点）的个数为n₀，度为2的结点数为n₂，则n₀=n₂+1。
4. 包含n个结点的二叉树的高度至少为log₂ (n+1)。
5. 具有n个结点的完全二叉树的深度为
     
   （注：[ ]表示向下取整）

二叉树的一些概念：

• 满二叉树：深度为k且含有2^k-1个结点的二叉树。（即除叶子结点外，所有结点都有左儿子和右儿子。
• 完全二叉树：若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

　　　　　　　　　　　　　　　　　　　　　　

　　　　　　满二叉树　　　　　

　

　　　　　　　　　　

　　　　　　完全二叉树　　　

　　　　　　

 　　　非完全二叉树

 

---

补充：

根据遍历序列确定一棵二叉树：

　　先序序列+中序序列   >>>

　　　　先：根左右 → 第一个一定是根

　　　　中：左根右 → 根据先序找到一个根后，把序列由根划分成左子树和右子树

　　　　对左子树和右子树进行同样的操作，直到子树为空。（可见也是一种递归思想。

　　中序序列+后序序列   >>>

　　　　后：左右根 → 序列的最后一个为根

　　　　中：左根右 → 根据后序找到一个根后，把序列由根划分成左子树和右子树

　　　　对左子树和右子树进行同样的操作，直到子树为空。（递归

　　先序加后序是无法确定一颗二叉树的，因为由上可见，中序由先序或后序提供的根来确定左右子树，没有中序是无法完成这个递归过程的，也就无法确定一颗二叉树。

---

接下来就是二叉树的代码了，它实现了二叉树的基本存储结构和一些基本的操作：

　　ps：这里注意一下先序遍历建立二叉树时的数据输入，要按根左右的顺序注意-1结束符的输入。

　　例：1 2 3 -1 -1 4 5 -1 6 -1 -1 7 -1 -1 -1

#include<iostream>
#include<stdlib.h>
#include<queue>        //层次遍历时要用到队列
using namespace std;

#define MAXSIZE 100
typedef int ElemType;
typedef int Status;

//二叉链表存储表示
typedef struct BiTNode
{
    ElemType data;                        //结点数据域
    struct BiTNode *lchild, *rchild;    //左右孩子指针
}BiTNode, *BiTree;

//初始化，构造一个空树
void InitBT(BiTree &T)
{
    T = NULL;
}

//先序遍历建立二叉树
void CreateBT(BiTree &T)
{
    ElemType ch;
    cin >> ch;
    if (ch == -1)        //输入元素，以-1结束
        T = NULL;
    else
    {
        T = (BiTNode *)malloc(sizeof(BiTNode));        //分配内存空间
        T->data = ch;
        CreateBT(T->lchild);                        //递归建立其左子树
        CreateBT(T->rchild);                        //递归建立其右子树
    }
}

//检查二叉树是否为空，空返回1，非空返回0
int EmptyBT(BiTree T)
{
    if (T == NULL)
        return 1;
    else
        return 0;
}

//二叉树的深度
int DepthBT(BiTree T)
{
    if (T == NULL)    //空树深度为0
        return 0;
    else
    {
        int a = DepthBT(T->lchild);                //递归求左子树深度
        int b = DepthBT(T->rchild);                //递归求右子树深度
        return (a > b ? (a + 1) : (b + 1));        //取最大的即为树的深度，注意加1
    }
}

//查找二叉树BT中值为x的结点，若查找成功返回1，否则返回0
int FindBT(BiTree T, ElemType x)
{
    if (T == NULL)
        return 0;
    if (T->data == x)
        return 1;
    if (FindBT(T->lchild, x) || FindBT(T->rchild, x))    //递归在它的左子树和右子树里面找
        return 1;
    else
        return 0;
}

//先序遍历，根左右
void  PreOrder(BiTree T)
{
    if (T)    //树非空
    {
        cout << T->data << " ";
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

//中序遍历，左根右
void InOrder(BiTree T)
{
    if (T)
    {
        InOrder(T->lchild);
        cout << T->data << " ";
        InOrder(T->rchild);
    }
}

//后序遍历，左右根
void  PostOrder(BiTree T)
{
    if (T)
    {
        InOrder(T->lchild);
        InOrder(T->rchild);
        cout << T->data << " ";
    }
}

//层次遍历
void  LevelOrder(BiTree T)
{
    BiTree p;
    if (T)
    {
        queue<BiTree>Q;        //创建一个队列Q
        Q.push(T);            //将树入队
        while (!Q.empty())    //队列非空
        {
            p = Q.front();
            Q.pop();
            cout << p->data << " ";
            if (p->lchild)        //先左子树出队
                Q.push(p->lchild);
            if (p->rchild)        //后右子树出队
                Q.push(p->rchild);
        }
    }
}

//叶子结点个数
int  LeafCount(BiTree T)
{
    if (!T)
        return 0;
    int count = 0;        //计数器
    if (!T->lchild && !T->rchild)        //左右子树都为空，则为一个叶子结点
    {
        count++;
    }
    int a = LeafCount(T->lchild);        //递归求其左子树叶子结点数
    int b = LeafCount(T->rchild);        //递归求其右子树叶子结点数
    count += (a + b);
    return count;
}

//总结点数
int  NodeCount(BiTree T)
{
    if (!T)
        return 0;
    else
        return NodeCount(T->lchild) + NodeCount(T->rchild) + 1;    //加一个根节点
}

//清除二叉树
void ClearBTree(BiTree &T)
{
    if (T)
    {
        ClearBTree(T->lchild);
        ClearBTree(T->rchild);
        delete T;
        T = NULL;
    }
}

int main()
{
    BiTree T;
    int x;

    T = NULL;

    cout << "1.建立二叉树
";

    cout << "2.先序遍历二叉树
";

    cout << "3.中序遍历二叉树
";

    cout << "4.后序遍历二叉树
";

    cout << "5.层次遍历二叉树
";

    cout << "6.查找二叉树中元素
";

    cout << "7.计算二叉树的深度
";

    cout << "8.计算二叉树的叶子结点个数
";

    cout << "9.计算二叉树的结点总个数
";

    cout << "10.清除二叉树
";

    cout << "0.退出
";

    int choose = 0;

    while (choose != -1)
    {
        cout << "请选择你要执行的操作：";
        cin >> choose;
        switch (choose)
        {
        case 1:    //先序遍历建立二叉树
            cout << "请输入二叉树中元素，以-1结束：";
            CreateBT(T);
            cout << "二叉树建立成功！" << endl;
            break;
        case 2:    //先序遍历输出二叉树
            PreOrder(T);
            cout << endl;
            break;
        case 3:    //中序遍历输出二叉树
            InOrder(T);
            cout << endl;
            break;
        case 4:    //后序遍历输出二叉树
            PostOrder(T);
            cout << endl;
            break;
        case 5:    //层次遍历输出二叉树
            LevelOrder(T);
            cout << endl;
            break;
        case 6:    //查找二叉树中是否存在元素x
            cout << "请输入要查找的元素x：";
            cin >> x;
            if (FindBT(T, x))
                cout << "查找成功！" << endl;
            else
                cout << "查找失败！" << endl;
            break;
        case 7:    //二叉树深度
            cout << DepthBT(T) << endl;
            break;
        case 8:    //叶子结点数
            cout << LeafCount(T) << endl;
            break;
        case 9:    //总结点数
            cout << NodeCount(T) << endl;
            break;
        case 10://清除二叉树
            ClearBTree(T);
            cout << "清除成功！" << endl;
            break;
        case 0:    //退出
            exit(0);
            break;
        }
    }
    system("pause");
    return 0;
}