数据结构之树 总结 (C语言)

树的相关概念

树中结点的最大层次称为树的深度

斜树：
#左斜树 ：所有的结点都只有左子树的二叉树
#右子树 ：所有的结点都只有右子树的二叉树

满二叉树：
所有的分支结点都存在左子树和右子树;
所有的叶子都在同一层上。

完全二叉树：
对一颗具有n个结点的二叉树按层序编号，编号为i的结点与同样深度的满二叉树中编号为i的结点在二叉树中的位置完全相同的树。

性质：

同样结点数的二叉树，完全二叉树的深度最小。

在二叉树的第i层上最多有2^i-1个结点

深度为k的结点最多有2^k-1 个结点

对任何一棵二叉树T,记其终端结点数为n₀,度为2的结点数为n₂,则n₀=n₂+1。

具有n个结点的完全二叉树的深度为$\lfloor lo{g}_{2}n\rfloor$+1

二叉树

二叉树的遍历：

前序遍历：根—>左—>右

中序遍历：左—>根—>右

后序遍历：左—>右—>根

层序遍历：从上到下，从左到右对结点逐个访问

注：中序+前序/中序+后序 可唯一确定一棵二叉树

赫夫曼树：带权路径长度WPL最小的二叉树

注意赫夫曼树的生成的算法，赫夫曼编码原理

树的相关操作：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#define OVERFLOW 0
#define MAX_TREE_SIZE 100
#define Status int
#define OK 1
#define ERROR 0

typedef int TElemType;      //树结点的数据类型，目前暂定为整形

typedef struct PTNode       //结点结构
{
   
    TElemType data;     //结点数据     
    int parent;     //双亲位置
}PTNode;

typedef struct
{
   
    PTNode node[MAX_TREE_SIZE];     //结点数组
    int r,n;        //根的位置和结点数
}PTree;

//树的孩子法结构定义
typedef struct CTNode       //孩子结点
{
   
    int child;
    struct CTNode *next;
}*ChildPtr;

//表头结构
typedef struct
{
   
    TElemType data;
    ChildPtr firstchild;
}CTBox;

typedef struct      //树结构
{
   
    CTBox nodes[MAX_TREE_SIZE];     //结点数组
    int r,n;        //根的位置和结点数
}CTree;

//树的孩子兄弟表示法结构定义
typedef struct CSNode
{
   
    TElemType data;
    struct CSNode *firstchild,*rightsib;
}CSNode,*CSTree;

//二叉树的二叉链表结点结构定义
typedef struct BiTNode      //结点结构
{
   
    TElemType data;     //结点数据
    struct BiTNode *lchild,*rchild;     //左右孩子指针
}BiTNode,*BiTree;

//二叉树的前序遍历递归算法
void PreOrderTraverse(BiTree T)
{
   
    if(T==NULL)
        return;
    printf("%c",T->data);       //显示结点数据,可以更改为其他对结点操作
    PreOrderTraverse(T->lchild);        //再先遍历左子树
    PreOrderTraverse(T->rchild);        //最后先序遍历右子树
}

//二叉树的中序遍历递归算法
void InOrderTraverse(BiTree T)
{
   
    if(T==NULL)
        return;
    InOrderTraverse(T->lchild);     //中序遍历左子树
    printf("%c",T->data);       //显示结点数据，可更改为其他对结点的操作
    InOrderTraverse(T->rchild);     //最后中序遍历右子树
}

//二叉树的后序遍历递归算法
void PostOrderTraverse(BiTree T)
{
   
    if(T==NULL)
        return;
    PostOrderTraverse(T->lchild);       //先后序遍历左子树
    PostOrderTraverse(T->rchild);       //再后序遍历右子树
}

//二叉树的建立
//按前序输入二叉树中的结点的值(一个字符)
//#表示空树，构造二叉链表表示二叉树T
void CreateBiTree(BiTree *T)
{
   
    TElemType ch;
    scanf("%c",ch);
    if(ch=='#')
        *T==NULL;
    else
    {
   
        *T=(BiTree)malloc(sizeof(BiTNode));
        if(!*T)
            exit(OVERFLOW);
        (*T)->data=ch;      //生成根节点
        CreateBiTree(&(*T)->lchild);       //构造左子树
        CreateBiTree(&(*T)->rchild);        //构造右子树
    }
}

//二叉树的二叉线索存储结构定义
typedef enum {
   Link,Thread} PointerTag;      //Link==0表示指向左右孩子指针，
//Thread==1表示指向前驱或后继的线索

typedef struct BiThrNode        //二叉线索存储结点结构
{
   
    TElemType data;         //结点数据
    struct BiThrNode *lchild,*rchild;       //左右孩子指针
    PointerTag LTag;
    PointerTag RTag;        //左右标志
}BiThrNode,*BiThrTree;

BiThrTree pre;      //全局变量，始终指向刚刚访问过的结点

//中序遍历进行中序线索化
void InThreading(BiThrTree p)
{
   
    if(p)
    {
   
        InThreading(p->lchild);     //递归左子树线索化
        if(!p->lchild)      //没有左孩子
        {
   
            p->LTag=Thread;     //前驱线索
            p->lchild=pre;      //左孩子指针指向前驱
        }
        if(!pre->rchild)        //前驱没有右孩子
        {
   
            pre->RTag=Thread;       //后继线索
            pre->rchild=p;      //前驱右孩子指针指向后继(当前结点p)
        }
        pre=p;      //保持pre指向p的前驱
        InThreading(p->rchild);     //递归右子树线索化
    }
}

/*
T指向头结点，头结点左链lchild指向根结点，头结点右链rchild指向
中序遍历的最后一个结点。中序遍历二叉线索链表表示的二叉树T
*/
Status InOrderTraverse_Thr(BiThrTree T)
{
   
    BiThrTree p;
    p=T->lchild;        //p指向根结点
    while (p!=T)     //空树或遍历结束时，p==T
    {
   
        while (p->LTag==Link)       //当LTag==0时循环到中序序列第一个结点
        {
   
            p=p->lchild;
        }
        printf("%c",p->data);       //显示结点数据，可更改为其他对结点操作
        while (p->RTag==Thread && p->rchild!=T)
        {
   
            p=p->rchild;
            printf("%c",p->data);
        }
        p=p->rchild;        //p进至右子树根
    }
    return OK;
}