树与二叉树

一.树的定义与基本术语

1.树的基本概念

树是n(n>=0)个节点的有限集合T。当n=0时，称为空树；当n>0时，该集合满足如下条件：

(1)其中必有一个称为根（root)的特定结点，它没有直接前驱，但有零个或多个直接后继。

(2)其余n-1个结点可以划分成m(m>=0)个互不相交的有限集T₁,T₂,...,T_m,其中T_i又是一棵树，称为树的子树。每棵子树的根节点有且只有一个直接前驱，但有零个或多个直接后继。

如下图，给出了一棵树的逻辑结构图示，如同一颗倒长的树：

2.树的图解表示方法

(1)倒置树结构（树形表示法),如上图所示。

(2)除了树形表示法，还有文氏图表示法（嵌套集合表示法）、广义表形式（嵌套括号表示法）、凹入表示法等，在这不做详解，具体可以参考《数据结构-----有C语言描述》。

3.树的相关术语

(1)结点：包括一个数据元素及若干指向其他结点的分支信息

(2)结点的度：一个节点的子树的个数称为该结点的度

(3)叶节点：度为0的结点，即无后继的结点，也称终端结点

(4)分支结点：度不为0的结点，也称非终端结点

(5)结点的层次：从根节点开始定义，根节点的层次为1，根的后继的结点的层次为2，依次类推

(6)树的度：树中所有结点度的最大值

(7)树的高度（深度）：树中所有结点的层次的最大值

(8)森林：将一个非空树的根节点删除后，树就变成一个森林，反之给森林加一个统一的根节点后，森林就变成一棵树

(9)同构：对两棵树，结点对应相等，对应结点的相关关系也相等

(10)孩子结点：一个节点的直接后继

(11)父亲结点：一个节点的直接前驱

(12)兄弟结点：同一双亲结点的孩子结点之间互称兄弟结点

例如，具有3个结点且不同构的有序树共有以下5种：

4.树的基本操作

InitTree:初始化树

DestoryTree:销毁树

CreatTree:创建树

TreeEmpty:判断树是否为空

Root:返回非空树的根

Delete:删除节点

二.二叉树

1.二叉树的定义与基本操作

定义：满足以下两个条件的树结构称为二叉树：（Binary Tree）

(1)每个结点的度都不大于2。

(2)每个结点的孩子结点次序不能任意颠倒

由此定义可以看出，一个二叉树中的每个节点只能包含有0、1或2个孩子，而且每个孩子有左右之分，位于左边的孩子称为左孩子，位于右边的孩子称为右孩子。

如下图是二叉树的5种基本形态：

基本操作：与树的基本操作类似

2.二叉树的性质

(1)在二叉树的第i层至多有2^i-1个结点（i>=1)。

(2)深度为k的二叉树至多有2^k-1个结点。

(3)对于任意一棵二叉树T，若终端结点的个数（叶子节点的个数）为n₀，而其度为2的结点数为n₂,则n₀=n₂+1。（根据分支数与结点的关系推出）。

　　满二叉树：深度为k的二叉树有2^k-1个结点的二叉树。

　　完全二叉树：完全二叉树的结点1·n编号的位置序号与满二叉树的编号相同，即一一对应。

(4)具有n个结点的完全二叉树的深度为log₂n+1。

(5)对于有n个结点的完全二叉树，如果按照从上往下和从左往右的顺序对二叉树中的所有结点从1开始编号，则对于序号为i的结点有：

　　a.i=1,则序号为i的结点是根节点，无双亲结点；如果i>1;则序号为i的结点的双亲结点的序号为i/2(向下取整)。

　　b.如2i>n,则编号为i的结点无左孩子与右孩子。如果2i<=n,则序号为i的结点的左孩子序号为2i,右孩子结点序号为2i+1。

3.二叉树的存储结构

二叉树的结构是非线性的，每个结点最多可有两个后继。二叉树的存储结构有两种：顺序存储结构和链式存储结构。

 (1)顺序存储结构

　　分完全二叉树、单支树这两种情况讨论，如下图：

　　　　

　　　　

(2)链式存储结构

对任意的二叉树来说，每个结点只有一个双亲结点（根节点除外），最多有两个孩子。可以设计每个结点至少包括三个域：数据域、左孩子域和右孩子域，如下图所示：

用C语言定义的我二叉树的二叉链表结点结构如下：

typedef struct Node
{
    DataType data;
    struct Node * Lchild;
    struct Node * Rchild;
}BiTreeNode,*pBiTree;

若一个二叉树含有n个结点，则它的二叉链表中必含2n个指针域，其中必有n+1个空指针域。（因为有n个结点，非空的链域必有n-1个，所以空的链域定有2n-（n-1）=n+1个）。

三.用C语言实现二叉树的基本操作

 

//BTNode.c
#include"BTree.h"

BTNode * LeftChild(BTNode *pRoot)//获取左孩子
{
    return pRoot != NULL ? pRoot->_pLift : NULL;
}
BTNode * RightChild(BTNode *pRoot)//获取右孩子
{
    return pRoot != NULL ? pRoot->_pLift : NULL;
}

int HeightBTree(BTNode *pRoot)
{
    int leftheight = 0;
    int  rightheight = 0;
    if (pRoot == NULL)
    {
        return 0;
    }
    leftheight = HeightBTree(pRoot->_pLift);
    rightheight = HeightBTree(pRoot->_pRight);
    return leftheight > rightheight ? leftheight+1 : rightheight+1;
}

int GetKLevelBTNodCount(BTNode *pRoot, int k)
{
    if (pRoot == NULL||k<=0)
    {
        return 0;
    }
    if (1 == k)
        return 1;
    return GetKLevelBTNodCount(pRoot->_pLift, k-1) + GetKLevelBTNodCount(pRoot->_pRight, k-1);
}

int GetLeafBTnodCount(BTNode *pRoot)
{
    if (pRoot == NULL)
    {
        return 0;
    }
    if (pRoot->_pLift == NULL&&pRoot->_pRight == NULL)
    {
        return 1;
    }
    return GetLeafBTnodCount(pRoot->_pLift) + GetLeafBTnodCount(pRoot->_pRight);
}

int GetBTNodeCount(BTNode *pRoot)
{
    if (pRoot == NULL)
    {
        return 0;
    }
    return GetBTNodeCount(pRoot->_pLift) + GetBTNodeCount(pRoot->_pRight) + 1;
}

void DestoryBinTree(BTNode **pRoot)//销毁二叉树
{
    assert(pRoot);
    if (*pRoot)
    {
        DestoryBinTree(&(*pRoot)->_pLift);//销毁左子树
        DestoryBinTree(&(*pRoot)->_pRight);//销毁右子树
        free(*pRoot);
        *pRoot = NULL;
    }
}

BTNode *CopyBinTree(BTNode *pRoot)//拷贝二叉树
{
    BTNode *pNewNode = NULL;
    if (pRoot)
    {
        
        pNewNode = BuyNewNode(pRoot->data);
        //拷贝左子树
        if (pRoot->_pLift)
            pNewNode->_pLift = CopyBinTree(pRoot->_pLift);
        //拷贝右子树
        if (pRoot->_pRight)
            pNewNode->_pRight = CopyBinTree(pRoot->_pRight);
    }
    return pNewNode;
}

void CreatBinTree(BTNode **pRoot, char *str, int size, int *index,BDataType invalid)//创建二叉树
{
    assert(pRoot != NULL);
    assert(index);
    if ('#'!=str[*index]&&(*index)<size)
    {
        *pRoot = BuyNewNode(str[*index]);
        (*index)++;
        CreatBinTree(&(*pRoot)->_pLift, str, size, index,invalid);//创建左子树
        (*index)++;
        CreatBinTree(&(*pRoot)->_pRight, str, size, index,invalid);//创建右子树
    }
}
BTNode *BuyNewNode(BDataType data)//购买新节点
{
    BTNode * pNewNode = (BTNode *)malloc(sizeof(BTNode));
    if (pNewNode == NULL)
    {
        assert(0);
        return NULL;
    }
    pNewNode->_pLift = NULL;
    pNewNode->_pRight = NULL;
    pNewNode->data = data;
    return pNewNode;
}
void PreBTNode(BTNode * pRoot)//先序遍历
{
    if (pRoot)
    {
        printf("%c", pRoot->data);
        PreBTNode(pRoot->_pLift);
        PreBTNode(pRoot->_pRight);
    }
}
void InBTNode(BTNode * pRoot)//中序遍历
{
    if (pRoot)
    {
        InBTNode(pRoot->_pLift);
        printf("%c", pRoot->data);
        InBTNode(pRoot->_pRight);
    }
}
void PostBTNode(BTNode *pRoot)//后序遍历
{
    if (pRoot)
    {
        PostBTNode(pRoot->_pLift);
        PostBTNode(pRoot->_pRight);
        printf("%c", pRoot->data);
    }
}
//test.c
#include"BTree.h"
void Test()
{
    char *str = "ABD###CE##F";
    BTNode *pRoot = NULL;
    BTNode *pRootC = NULL;
    int index = 0;
    CreatBinTree(&pRoot, str, strlen(str), &index,'#');//创建二叉树
    printf("前序遍历：");
    PreBTNode(pRoot);
    printf("
");
    printf("中序遍历：");
    InBTNode(pRoot);
    printf("
");
    printf("后序遍历：");
    PostBTNode(pRoot);
    printf("
");
    pRootC = CopyBinTree(pRoot);
    printf("前序遍历：");
    PreBTNode(pRootC);
    printf("
");
    printf("中序遍历：");
    InBTNode(pRootC);
    printf("
");
    printf("后序遍历：");
    PostBTNode(pRootC);
    printf("
");
    printf("二叉树中节点的总个数：");
    printf("%d ", GetBTNodeCount(pRoot));
    printf("
");
    printf("二叉树中叶子节点的个数：");
    printf("%d ", GetLeafBTnodCount(pRoot));
    printf("
");
    printf("二叉树中第3层中节点的个数：");
    printf("%d", GetKLevelBTNodCount(pRoot, 3));
    printf("
");
    printf("二叉树的高度：");
    printf("%d ", HeightBTree(pRoot));
    DestoryBinTree(&pRoot);
    DestoryBinTree(&pRootC);
}

int main()
{
    Test();
    system("pause");
    return 0;
}
//BTNode.h:
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int BDataType;
typedef struct BTNode
{
    struct BTNode *_pLift;
    struct BTNode *_pRight;
    BDataType data;
}BTNode;

void CreatBinTree(BTNode **pRoot, char *str, int size, int *index,BDataType invalid);//创建二叉树
void PreBTNode(BTNode * pRoot);//先序遍历
void InBTNode(BTNode * pRoot);//中序遍历
void PostBTNode(BTNode *pRoot);//后序遍历
BTNode *BuyNewNode(BDataType data);//购买新节点
BTNode *CopyBinTree(BTNode *pRoot);//拷贝新节点
void DestoryBinTree(BTNode **pRoot);//销毁二叉树
int GetBTNodeCount(BTNode *pRoot);//获取二叉树的结点个数
int GetLeafBTnodCount(BTNode *pRoot);//获取叶子节点的个数
int GetKLevelBTNodCount(BTNode *pRoot,int k);//获取第K层节点的个数
int HeightBTree(BTNode *pRoot);//获取二叉树的高度
BTNode * LeftChild(BTNode *pRoot);//获取左右孩子
BTNode * RightChild(BTNode *pRoot);