數據結構——樹

時間  2019-12-09
標籤 數據 結構 简体版
原文   原文鏈接

一、樹的相關定義node

 

（1）樹：包含n（n>0）個節點的有窮集合，其中每一個元素稱爲節點（node）；有一個特定的節點被稱爲根節點或樹根（root）；除根節點以外的其他數據元素被分爲m（m≥0）個互不相交的結合T1，T2，……Tm-1，而其中每個集合Ti（1<=i<=m）自己也是一棵樹，被稱做原樹的子樹（subtree）。數組

（2）節點的度：一個節點含有的子樹的個數稱爲該節點的度；函數

（3）樹的度：一棵樹中，最大的節點的度稱爲樹的度；spa

（4）葉節點或終端節點：度爲零的節點稱爲葉節點；.net

（5）分支節點或非終端節點：度不爲零的節點；指針

（6）父節點或雙親節點：若一個結點含有子節點，則這個節點稱爲其子節點的父節點；code

（7）子節點或孩子節點：一個節點含有的子樹的根節點稱爲該節點的子節點；orm

（8）兄弟節點：具備相同父節點的節點互稱爲兄弟節點；blog

（9）節點的祖先：從根到該節點所經分支上的全部節點；排序

（10）子孫：以某節點爲根的子樹中任一節點都稱爲該節點的子孫。

（11）節點的層次：從根開始定義起，根爲第1層，根的子結點爲第2層，以此類推；

（12）樹的深度或高度：定義一棵樹的根結點層次爲1，其餘節點的層次是其父結點層次加1。一棵樹中全部結點的層次的最大值稱爲這棵樹的深度。

（13）森林：由m（m>=0）棵互不相交的樹的集合稱爲森林；

 

二、樹的特色

（1）每一個節點有零個或多個子節點。

（2）每一個子節點只有一個父節點。

（3）沒有父節點的節點稱爲根節點。

 

三、樹的分類

根據形態能夠分爲如下兩種：

（1）二叉樹

  • 滿二叉樹
  • 徹底二叉樹
  • 斜樹

（2）多叉樹

還有其餘根據應用特性而命名的樹，好比線索二叉樹、平衡二叉樹、二叉排序樹、多路查找樹（2-3樹、2-3-4樹、B樹、B+樹等）、最小生成樹等，本質是上述兩種類型。

 

四、樹的特色和性質

因爲實際中二叉樹用得最多，並且多叉樹能夠轉化成二叉樹，所以主要講二叉樹的性質。

性質1：在二叉樹的第i層上，至多有2^（i-1）個節點。

性質2：深度爲k的二叉樹，至多有2^k-1個節點。

性質3：對任何的一顆二叉樹，若是其終端節點（葉子節點）數爲n0，度爲2的節點數爲n2，則有n0=n2+1。

性質4：具備n個節點的徹底二叉樹的深度爲 [ log2(n) ]+1（[ x ]表示不大於x的最大整數）。

性質5：有n個節點的徹底二叉樹，從第一層到[ log2(n) ]+1層，每層從左到右編號，對任一節點i，若是i=1，則是二叉樹的根；若是i>1，則 [ i / 2 ]是其父節點；若是2i>n，則i無左孩子，不然其左孩子是2i；若是2i+1>n，則節點無右孩子，不然右孩子是2i+1。

 

五、樹的表示（存儲結構）

因爲實際中二叉樹用得最多，並且多叉樹能夠轉化成二叉樹，所以主要講二叉樹的存儲結構，即如何表示二叉樹結構，和建立實際的二叉樹。這裏有幾種表示方法：

（1）孩子兄弟表示法：每一個節點設置兩個指針，分別指向該節點的第一個孩子和此節點的兄弟。

 

[cpp]  view plain  copy
 
  1. typedef struct TreeNode  
  2. {  
  3.     int data;  
  4.     //other data information  
  5.     struct TreeNode *fisrtchild;  
  6.     struct TreeNode *BrotherNode;  
  7. }node;  


（2）子節點表示法；

 

（3）父節點表示法；

 

六、樹的操做與用途

（1）遍歷二叉樹，如前序、後序、中序遍歷（並推導遍歷結果）；

（2）對樹進行節點的刪減和添加；

（3）運用於查找（平衡二叉樹、多路查找樹），排序（（堆）排序等）等；

 

二叉樹順序結構實現

#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存儲空間初始分配量 */
#define MAX_TREE_SIZE 100 /* 二叉樹的最大結點數 */

typedef int Status;        /* Status是函數的類型,其值是函數結果狀態代碼，如OK等 */
typedef int TElemType;  /* 樹結點的數據類型，目前暫定爲整型 */
typedef TElemType SqBiTree[MAX_TREE_SIZE]; /* 0號單元存儲根結點  */

typedef struct
{
    int level,order; /* 結點的層,本層序號(按滿二叉樹計算) */
}Position;

TElemType Nil=0; /*  設整型以0爲空 */

Status visit(TElemType c)
{
    printf("%d ",c);
    return OK;
}

/* 構造空二叉樹T。由於T是固定數組，不會改變，故不須要& */
Status InitBiTree(SqBiTree T)
{
    int i;
    for(i=0;i<MAX_TREE_SIZE;i++)
        T[i]=Nil; /* 初值爲空 */
    return OK;
}

/* 按層序次序輸入二叉樹中結點的值(字符型或整型), 構造順序存儲的二叉樹T */
Status CreateBiTree(SqBiTree T)
{ 
    int i=0;
     printf("請按層序輸入結點的值(整型)，0表示空結點，輸999結束。結點數≤%d:\n",MAX_TREE_SIZE);
    while(i<10)
    {
        T[i]=i+1;
        
        if(i!=0&&T[(i+1)/2-1]==Nil&&T[i]!=Nil) /* 此結點(不空)無雙親且不是根 */
        {
            printf("出現無雙親的非根結點%d\n",T[i]);
            exit(ERROR);
        }
        i++;
    }
    while(i<MAX_TREE_SIZE)
    {
        T[i]=Nil; /* 將空賦值給T的後面的結點 */
        i++;
    }

    return OK;
}

#define ClearBiTree InitBiTree /* 在順序存儲結構中，兩函數徹底同樣 */

/* 初始條件: 二叉樹T存在 */
/* 操做結果: 若T爲空二叉樹,則返回TRUE,不然FALSE */
Status BiTreeEmpty(SqBiTree T)
{ 
    if(T[0]==Nil) /* 根結點爲空,則樹空 */
        return TRUE;
    else
        return FALSE;
}

/* 初始條件: 二叉樹T存在。操做結果: 返回T的深度 */
int BiTreeDepth(SqBiTree T)
{ 
   int i,j=-1;
   for(i=MAX_TREE_SIZE-1;i>=0;i--) /* 找到最後一個結點 */
     if(T[i]!=Nil)
       break;
   i++; 
   do
     j++;
   while(i>=powl(2,j));/* 計算2的j次冪。 */
   return j;
}

/* 初始條件: 二叉樹T存在 */
/* 操做結果:  當T不空,用e返回T的根,返回OK;不然返回ERROR,e無定義 */
Status Root(SqBiTree T,TElemType *e)
{ 
    if(BiTreeEmpty(T)) /* T空 */
        return ERROR;
    else
    {    
        *e=T[0];
        return OK;
    }
}

/* 初始條件: 二叉樹T存在,e是T中某個結點(的位置) */
/* 操做結果: 返回處於位置e(層,本層序號)的結點的值 */
TElemType Value(SqBiTree T,Position e)
{ 
     return T[(int)powl(2,e.level-1)+e.order-2];
}

/* 初始條件: 二叉樹T存在,e是T中某個結點(的位置) */
/* 操做結果: 給處於位置e(層,本層序號)的結點賦新值value */
Status Assign(SqBiTree T,Position e,TElemType value)
{ 
    int i=(int)powl(2,e.level-1)+e.order-2; /* 將層、本層序號轉爲矩陣的序號 */
    if(value!=Nil&&T[(i+1)/2-1]==Nil) /* 給葉子賦非空值但雙親爲空 */
        return ERROR;
    else if(value==Nil&&(T[i*2+1]!=Nil||T[i*2+2]!=Nil)) /*  給雙親賦空值但有葉子（不空） */
        return ERROR;
    T[i]=value;
    return OK;
}

/* 初始條件: 二叉樹T存在,e是T中某個結點 */
/* 操做結果: 若e是T的非根結點,則返回它的雙親,不然返回＂空＂ */
TElemType Parent(SqBiTree T,TElemType e)
{ 
    int i;
    if(T[0]==Nil) /* 空樹 */
        return Nil;
    for(i=1;i<=MAX_TREE_SIZE-1;i++)
        if(T[i]==e) /* 找到e */
            return T[(i+1)/2-1];
    return Nil; /* 沒找到e */
}


/* 初始條件: 二叉樹T存在,e是T中某個結點 */
/* 操做結果: 返回e的左孩子。若e無左孩子,則返回＂空＂ */
TElemType LeftChild(SqBiTree T,TElemType e)
{ 
    int i;
    if(T[0]==Nil) /* 空樹 */
        return Nil;
    for(i=0;i<=MAX_TREE_SIZE-1;i++)
        if(T[i]==e) /* 找到e */
            return T[i*2+1];
    return Nil; /* 沒找到e */
}

/* 初始條件: 二叉樹T存在,e是T中某個結點 */
/* 操做結果: 返回e的右孩子。若e無右孩子,則返回＂空＂ */
TElemType RightChild(SqBiTree T,TElemType e)
{ 
    int i;
    if(T[0]==Nil) /* 空樹 */
        return Nil;
    for(i=0;i<=MAX_TREE_SIZE-1;i++)
        if(T[i]==e) /* 找到e */
            return T[i*2+2];
    return Nil; /* 沒找到e */
}

/* 初始條件: 二叉樹T存在,e是T中某個結點 */
/* 操做結果: 返回e的左兄弟。若e是T的左孩子或無左兄弟,則返回＂空＂ */
TElemType LeftSibling(SqBiTree T,TElemType e)
{ 
    int i;
    if(T[0]==Nil) /* 空樹 */
        return Nil;
    for(i=1;i<=MAX_TREE_SIZE-1;i++)
        if(T[i]==e&&i%2==0) /* 找到e且其序號爲偶數(是右孩子) */
            return T[i-1];
    return Nil; /* 沒找到e */
}

/* 初始條件: 二叉樹T存在,e是T中某個結點 */
/* 操做結果: 返回e的右兄弟。若e是T的右孩子或無右兄弟,則返回＂空＂ */
TElemType RightSibling(SqBiTree T,TElemType e)
{ 
    int i;
    if(T[0]==Nil) /* 空樹 */
        return Nil;
    for(i=1;i<=MAX_TREE_SIZE-1;i++)
        if(T[i]==e&&i%2) /* 找到e且其序號爲奇數(是左孩子) */
            return T[i+1];
    return Nil; /* 沒找到e */
}

/* PreOrderTraverse()調用 */
void PreTraverse(SqBiTree T,int e)
{ 
    visit(T[e]);
    if(T[2*e+1]!=Nil) /* 左子樹不空 */
        PreTraverse(T,2*e+1);
    if(T[2*e+2]!=Nil) /* 右子樹不空 */
        PreTraverse(T,2*e+2);
}

/* 初始條件: 二叉樹存在 */
/* 操做結果: 先序遍歷T。 */
Status PreOrderTraverse(SqBiTree T)
{ 
    if(!BiTreeEmpty(T)) /* 樹不空 */
     PreTraverse(T,0);
    printf("\n");
    return OK;
}

/* InOrderTraverse()調用 */
void InTraverse(SqBiTree T,int e)
{ 
    if(T[2*e+1]!=Nil) /* 左子樹不空 */
        InTraverse(T,2*e+1);
    visit(T[e]);
    if(T[2*e+2]!=Nil) /* 右子樹不空 */
        InTraverse(T,2*e+2);
}

/* 初始條件: 二叉樹存在 */
/* 操做結果: 中序遍歷T。 */
Status InOrderTraverse(SqBiTree T)
{ 
    if(!BiTreeEmpty(T)) /* 樹不空 */
        InTraverse(T,0);
    printf("\n");
    return OK;
}

/* PostOrderTraverse()調用 */
void PostTraverse(SqBiTree T,int e)
{ 
    if(T[2*e+1]!=Nil) /* 左子樹不空 */
        PostTraverse(T,2*e+1);
    if(T[2*e+2]!=Nil) /* 右子樹不空 */
        PostTraverse(T,2*e+2);
    visit(T[e]);
}

/* 初始條件: 二叉樹T存在 */
/* 操做結果: 後序遍歷T。 */
Status PostOrderTraverse(SqBiTree T)
{ 
    if(!BiTreeEmpty(T)) /* 樹不空 */
        PostTraverse(T,0);
    printf("\n");
    return OK;
}

/* 層序遍歷二叉樹 */
void LevelOrderTraverse(SqBiTree T)
{ 
    int i=MAX_TREE_SIZE-1,j;
    while(T[i]==Nil)
        i--; /* 找到最後一個非空結點的序號 */
    for(j=0;j<=i;j++)  /* 從根結點起,按層序遍歷二叉樹 */
        if(T[j]!=Nil)
            visit(T[j]); /* 只遍歷非空的結點 */
    printf("\n");
}

/* 逐層、按本層序號輸出二叉樹 */
void Print(SqBiTree T)
{ 
    int j,k;
    Position p;
    TElemType e;
    for(j=1;j<=BiTreeDepth(T);j++)
    {
        printf("第%d層: ",j);
        for(k=1;k<=powl(2,j-1);k++)
        {
            p.level=j;
            p.order=k;
            e=Value(T,p);
            if(e!=Nil)
                printf("%d:%d ",k,e);
        }
        printf("\n");
    }
}


int main()
{
    Status i;
    Position p;
    TElemType e;
    SqBiTree T;
    InitBiTree(T);
    CreateBiTree(T);
    printf("創建二叉樹後,樹空否？%d(1:是 0:否) 樹的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
    i=Root(T,&e);
    if(i)
        printf("二叉樹的根爲：%d\n",e);
    else
        printf("樹空，無根\n");
    printf("層序遍歷二叉樹:\n");
    LevelOrderTraverse(T);
    printf("前序遍歷二叉樹:\n");
    PreOrderTraverse(T);
    printf("中序遍歷二叉樹:\n");
    InOrderTraverse(T);
    printf("後序遍歷二叉樹:\n");
    PostOrderTraverse(T);
    printf("修改結點的層號3本層序號2。");
    p.level=3;
    p.order=2;
    e=Value(T,p);
    printf("待修改結點的原值爲%d請輸入新值:50 ",e);
    e=50;
    Assign(T,p,e);
    printf("前序遍歷二叉樹:\n");
    PreOrderTraverse(T);
    printf("結點%d的雙親爲%d,左右孩子分別爲",e,Parent(T,e));
    printf("%d,%d,左右兄弟分別爲",LeftChild(T,e),RightChild(T,e));
    printf("%d,%d\n",LeftSibling(T,e),RightSibling(T,e));
    ClearBiTree(T);
    printf("清除二叉樹後,樹空否？%d(1:是 0:否) 樹的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
    i=Root(T,&e);
    if(i)
        printf("二叉樹的根爲：%d\n",e);
    else
        printf("樹空，無根\n");
    
    return 0;
}

鏈式結構實現

#include "string.h"
#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存儲空間初始分配量 */

typedef int Status;        /* Status是函數的類型,其值是函數結果狀態代碼，如OK等 */

/* 用於構造二叉樹********************************** */
int index=1;
typedef char String[24]; /*  0號單元存放串的長度 */
String str;

Status StrAssign(String T,char *chars)
{ 
    int i;
    if(strlen(chars)>MAXSIZE)
        return ERROR;
    else
    {
        T[0]=strlen(chars);
        for(i=1;i<=T[0];i++)
            T[i]=*(chars+i-1);
        return OK;
    }
}
/* ************************************************ */

typedef char TElemType;
TElemType Nil=' '; /* 字符型以空格符爲空 */

Status visit(TElemType e)
{
    printf("%c ",e);
    return OK;
}

typedef struct BiTNode  /* 結點結構 */
{
   TElemType data;        /* 結點數據 */
   struct BiTNode *lchild,*rchild; /* 左右孩子指針 */
}BiTNode,*BiTree;


/* 構造空二叉樹T */
Status InitBiTree(BiTree *T)
{ 
    *T=NULL;
    return OK;
}

/* 初始條件: 二叉樹T存在。操做結果: 銷燬二叉樹T */
void DestroyBiTree(BiTree *T)
{ 
    if(*T) 
    {
        if((*T)->lchild) /* 有左孩子 */
            DestroyBiTree(&(*T)->lchild); /* 銷燬左孩子子樹 */
        if((*T)->rchild) /* 有右孩子 */
            DestroyBiTree(&(*T)->rchild); /* 銷燬右孩子子樹 */
        free(*T); /* 釋放根結點 */
        *T=NULL; /* 空指針賦0 */
    }
}

/* 按前序輸入二叉樹中結點的值（一個字符） */
/* #表示空樹，構造二叉鏈表表示二叉樹T。 */
void CreateBiTree(BiTree *T)
{ 
    TElemType ch;
    
    /* scanf("%c",&ch); */
    ch=str[index++];

    if(ch=='#') 
        *T=NULL;
    else
    {
        *T=(BiTree)malloc(sizeof(BiTNode));
        if(!*T)
            exit(OVERFLOW);
        (*T)->data=ch; /* 生成根結點 */
        CreateBiTree(&(*T)->lchild); /* 構造左子樹 */
        CreateBiTree(&(*T)->rchild); /* 構造右子樹 */
    }
 }

/* 初始條件: 二叉樹T存在 */
/* 操做結果: 若T爲空二叉樹,則返回TRUE,不然FALSE */
Status BiTreeEmpty(BiTree T)
{ 
    if(T)
        return FALSE;
    else
        return TRUE;
}

#define ClearBiTree DestroyBiTree

/* 初始條件: 二叉樹T存在。操做結果: 返回T的深度 */
int BiTreeDepth(BiTree T)
{
    int i,j;
    if(!T)
        return 0;
    if(T->lchild)
        i=BiTreeDepth(T->lchild);
    else
        i=0;
    if(T->rchild)
        j=BiTreeDepth(T->rchild);
    else
        j=0;
    return i>j?i+1:j+1;
}

/* 初始條件: 二叉樹T存在。操做結果: 返回T的根 */
TElemType Root(BiTree T)
{ 
    if(BiTreeEmpty(T))
        return Nil;
    else
        return T->data;
}

/* 初始條件: 二叉樹T存在，p指向T中某個結點 */
/* 操做結果: 返回p所指結點的值 */
TElemType Value(BiTree p)
{
    return p->data;
}

/* 給p所指結點賦值爲value */
void Assign(BiTree p,TElemType value)
{
    p->data=value;
}

/* 初始條件: 二叉樹T存在 */
/* 操做結果: 前序遞歸遍歷T */
void PreOrderTraverse(BiTree T)
{ 
    if(T==NULL)
        return;
    printf("%c",T->data);/* 顯示結點數據，能夠更改成其它對結點操做 */
    PreOrderTraverse(T->lchild); /* 再先序遍歷左子樹 */
    PreOrderTraverse(T->rchild); /* 最後先序遍歷右子樹 */
}

/* 初始條件: 二叉樹T存在 */
/* 操做結果: 中序遞歸遍歷T */
void InOrderTraverse(BiTree T)
{ 
    if(T==NULL)
        return;
    InOrderTraverse(T->lchild); /* 中序遍歷左子樹 */
    printf("%c",T->data);/* 顯示結點數據，能夠更改成其它對結點操做 */
    InOrderTraverse(T->rchild); /* 最後中序遍歷右子樹 */
}

/* 初始條件: 二叉樹T存在 */
/* 操做結果: 後序遞歸遍歷T */
void PostOrderTraverse(BiTree T)
{
    if(T==NULL)
        return;
    PostOrderTraverse(T->lchild); /* 前後序遍歷左子樹  */
    PostOrderTraverse(T->rchild); /* 再後序遍歷右子樹  */
    printf("%c",T->data);/* 顯示結點數據，能夠更改成其它對結點操做 */
}


int main()
{
    int i;
    BiTree T;
    TElemType e1;
    InitBiTree(&T);

    
    StrAssign(str,"ABDH#K###E##CFI###G#J##");

    CreateBiTree(&T);

    printf("構造空二叉樹後,樹空否？%d(1:是 0:否) 樹的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
    e1=Root(T);
    printf("二叉樹的根爲: %c\n",e1);

    printf("\n前序遍歷二叉樹:");
    PreOrderTraverse(T);
    printf("\n中序遍歷二叉樹:");
    InOrderTraverse(T);
    printf("\n後序遍歷二叉樹:");
    PostOrderTraverse(T);
    ClearBiTree(&T);
    printf("\n清除二叉樹後,樹空否？%d(1:是 0:否) 樹的深度=%d\n",BiTreeEmpty(T),BiTreeDepth(T));
    i=Root(T);
    if(!i)
        printf("樹空，無根\n");
    
    return 0;
}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程