2. 程式人生 > >第4章第1節練習題4 二叉樹高度和寬度統計

第4章第1節練習題4 二叉樹高度和寬度統計

阿新 • • 發佈：2019-02-01

為了方便說明二叉樹的遞迴傳值過程，這裡首先給出一個基本的二叉樹結構。
二叉樹
圖中值為NULL的節點實際是不存在的，故與父親節點之間的連線用灰色的虛線表示。只是為了便於說明，才假設了一個NULL的空節點。
以下圖中，黃色的線表明了傳值的方向；綠色的數值表明了子節點傳到父親節點時的值，即根據遞迴公式計算便可。

一.計算二叉樹的高度（遞迴/非遞迴）

遞迴方式實現

對於高度的計算，首先是從葉子結點算起，假設葉子結點下面的NULL節點高度為0，則葉子結點的高度便為1，那麼葉子結點的雙親節點便為2，以此類推便可以得到根節點的高度，這樣也就得到了整棵二叉樹的高度。其基本的遞迴公式如下：

f
(T)=⎧⎩⎨0,f(T−>lchild)+1,f(T−>rchild)+1,若T=NULL若T的左孩子高度>T的右孩子高度若T的右孩子高度>=T的左孩子高度

具體執行過程可以參考下圖，
HR
當指標遍歷到葉子結點的孩子結點(NULL結點)時，向葉子結點返回0，然後由葉子結點判斷來自左邊的孩子結點(NULL結點)和來自右邊的孩子結點(其實還是NULL結點)的返回值誰比較大，因為葉子結點處的值均由NULL結點返回，因此相等，則取右邊NULL結點的值，然後+1，表示葉子結點的高度。然後再由葉子結點向其雙親節點返回值，依次類推便可以得到整棵樹的高度。

演算法描述如下

int
 
 CntHeight_recursive(BiTNode* T){
    int lh,rh;
    if(T==NULL){
        return 0;
    }
    lh=CntHeight_recursive(T->lchild);
    rh=CntHeight_recursive(T->rchild);
    return lh>rh?lh+1:rh+1;
}

非遞迴方式實現

採用層次遍歷的演算法，設定變數cnt表示當前結點所在層次，設定變數last指向當前層最右結點，每次層次遍歷出隊時與last相比較，如果兩者相等，那麼層數+1，並讓last指向下一層最右結點，直至遍歷完成。level的值即為二叉樹的高度。
關於last指標的特性應該注意到，當隊首指標front指向last識別符號時，其隊尾指標rear剛好會指向下一層的隊尾元素。

演算法描述如下

int CntHeight_norecursive(BiTNode* T){
    BiTNode* p=T;
    SqQueue Q;

    InitQueue(&Q);
    EnQueue(&Q,p);

    int cnt=0;
    int last=1;

    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }

        if(Q.front==last){
            cnt++;
            last=Q.rear;
        }
    }
    return cnt;
}

二.計算二叉樹的寬度（非遞迴）

關於遞迴方式，個人沒有想到特別好的解決方案，這裡主要以非遞迴方式實現。
非遞迴方式的實現方式與計算二叉樹寬度的非遞迴實現方式類似，完全可以利用last指標的特性，即當隊首指標front指向last時，此時隊尾指標rear會剛好指向二叉樹下一層的最右邊結點，此時只需要用隊尾指標rear減去隊首指標便可以得到該層的寬度。而二叉樹的寬度則指的是從根節點到葉子結點的某層中元素最多的一層，因此只需要將每層的寬度儲存下來取最大值便可。

非遞迴方式實現

int CntWidth_norecursive(BiTNode* T){
    BiTNode* p=T;
    SqQueue Q;

    InitQueue(&Q);
    EnQueue(&Q,p);

    int cnt=0;
    int last=1;

    int level[MaxSize]={0};

    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }

        if(Q.front==last){
            level[cnt++]=Q.rear-Q.front;
            last=Q.rear;
        }
    }

    int max=level[0];
    for(int i=0;i<cnt;i++){
        if(max<level[i]){
            max=level[i];
        }
    }

    return max;
}

具體程式碼見附件。

附件

//統計二叉樹的高度和寬度
//AB#DG###CE##F##
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 10
typedef char ElemType;
typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

typedef struct{
    BiTNode* data[MaxSize];
    int front, rear;
}SqQueue;

BiTNode* CreateBiTree(BiTNode*);

void InitQueue(SqQueue*);
void EnQueue(SqQueue*,BiTNode*);
BiTNode* DeQueue(SqQueue*);
int IsEmptyQueue(SqQueue*);

void PreOrder(BiTNode*);
void InOrder(BiTNode*);

int CntHeight_recursive(BiTNode*);
int CntHeight_norecursive(BiTNode*);

int CntWidth_norecursive(BiTNode*);

//-------------------------------------------------------------------------------------

int main(int argc, char* argv[]){
    BiTNode* T=(BiTNode*)malloc(sizeof(BiTNode));
    T=CreateBiTree(T);

    PreOrder(T);printf("\n");
    InOrder(T);printf("\n");

    int count;

    count=CntHeight_recursive(T);
    printf("recursive:The height of BiTree is %d\n",count);

    count=CntHeight_norecursive(T);
    printf("non-recursive:The height of BiTree is %d\n",count);

    count=CntWidth_norecursive(T);
    printf("non-recursive:The Width of BiTree is %d\n",count);

    return 0;
}

//-------------------------------------------------------------------------------------

BiTNode* CreateBiTree(BiTNode* T){
    ElemType ch;
    scanf("%c",&ch);
    if(ch=='#'){
        return NULL;
    }
    T=(BiTNode*)malloc(sizeof(BiTNode));
    T->data=ch;
    T->lchild=CreateBiTree(T->lchild);
    T->rchild=CreateBiTree(T->rchild);
    return T;
}

//-------------------------------------------------------------------------------------

//統計二叉樹的高度（遞迴）
int CntHeight_recursive(BiTNode* T){
    int lh,rh;
    if(T==NULL){
        return 0;
    }
    lh=CntHeight_recursive(T->lchild);
    rh=CntHeight_recursive(T->rchild);
    return lh>rh?lh+1:rh+1;
}

//統計二叉樹的高度（非遞迴）
int CntHeight_norecursive(BiTNode* T){
    BiTNode* p=T;
    SqQueue Q;

    InitQueue(&Q);
    EnQueue(&Q,p);

    int cnt=0;
    int last=1;

    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }

        if(Q.front==last){
            cnt++;
            last=Q.rear;
        }
    }
    return cnt;
}

//-------------------------------------------------------------------------------------

//統計二叉樹的寬度（非遞迴）
int CntWidth_norecursive(BiTNode* T){
    BiTNode* p=T;
    SqQueue Q;

    InitQueue(&Q);
    EnQueue(&Q,p);

    int cnt=0;
    int last=1;

    int level[MaxSize]={0};

    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }

        if(Q.front==last){
            level[cnt++]=Q.rear-Q.front;
            last=Q.rear;
        }
    }

    int max=level[0];
    for(int i=0;i<cnt;i++){
        if(max<level[i]){
            max=level[i];
        }
    }

    return max;
}

//-------------------------------------------------------------------------------------

//先序遍歷
void PreOrder(BiTNode* T){
    if(T==NULL){
        return;
    }
    printf("%c",T->data);
    PreOrder(T->lchild);
    PreOrder(T->rchild);
}

//中序遍歷
void InOrder(BiTNode* T){
    if(T==NULL){
        return;
    }
    InOrder(T->lchild);
    printf("%c",T->data);
    InOrder(T->rchild);
}

//-------------------------------------------------------------------------------------

void InitQueue(SqQueue* Q){
    Q->front=0;
    Q->rear=0;
}

void EnQueue(SqQueue* Q, BiTNode* T){
    if((Q->rear+1)%MaxSize==Q->front){
        return;
    }
    Q->data[Q->rear++]=T;
}

BiTNode* DeQueue(SqQueue* Q){
    if(Q->front==Q->rear){
        return NULL;
    }
    return Q->data[Q->front++];
}

int IsEmptyQueue(SqQueue* Q){
    if(Q->rear==Q->front){
        return 0;
    }else{
        return -1;
    }
}

相關推薦

第4章第1節練習題4 二叉樹高度和寬度統計

為了方便說明二叉樹的遞迴傳值過程，這裡首先給出一個基本的二叉樹結構。 圖中值為NULL的節點實際是不存在的，故與父親節點之間的連線用灰色的虛線表示。只是為了便於說明，才假設了一個NULL的空節點。 以下圖中，黃色的線表明了傳值的方向；綠色的數值表明了子節

第4章第1節練習題2 二叉樹的基本操作（非遞迴實現）

二叉樹的非遞迴遍歷 上一節二叉樹的遞迴遍歷中簡單介紹了二叉樹的遞迴遍歷的實現方式，本節主要介紹二叉樹的非遞迴遍歷實現，繼續引用上節的例子來說明下。 一.先序遍歷 二叉樹先序遍歷的訪問順序為：根結點->左孩子->右孩子。簡單的說，對於任意

第4章第1節練習題6 二叉樹葉子節點連結成單鏈表

問題描述 設計一個演算法，將二叉樹的葉子節點按從左到右的順序連成一個單鏈表，表頭指標為head。連結時用葉子節點的右指標來存放單鏈表指標。 演算法思想 題目要求將葉子節點按自左向

第六章樹和二叉樹作業1—二叉樹--計算機17級 6-1 求二叉樹高度 （20 分）

6-1 求二叉樹高度 （20 分） 本題要求給定二叉樹的高度。 函式介面定義： int GetHeight( BinTree BT ); 其中BinTree結構定義如下： typedef struct TNode *Position; typedef P

[從頭學數學] 第243節 關於平衡二叉樹的Python實現

劇情提要：阿偉看到了一本比較有趣的書，是關於《計算幾何》的，2008年由北清派出版。很好奇它裡面講了些什麼，就來看看啦。正劇開始： 星曆2016年07月23日 16:30:59, 銀河系厄爾斯星球中華帝國江南行省。 [工程師阿偉]正在和[機器小偉]一起研究[計算幾何]]。

4.5 使用元組-非平衡二叉樹

delete(Key, nil) -> nil; delete(Key, {Key,_,nil,nil}) -> nil; delete(Key, {Key,_,Smaller,nil}) -> Smaller; delete(Key, {K

第九周專案三C/C++利用二叉樹遍歷思想解決問題

/* *Copyright (c) 2017,煙臺大學計算機與控制工程學院 *All rights reserved. *檔名稱：.cpp *完成日期：2017年11月16日 *版 本 號：v1.0 * 利用二叉樹遍歷思想解決問題 /* 【利

練習題之二叉樹的映象

題目： 操作給定的二叉樹，將其變換為源二叉樹的映象。 程式碼實現： /** public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null;

6-1 求二叉樹高度 （20 分）

本題要求給定二叉樹的高度。 函式介面定義： int GetHeight( BinTree BT ); 其中BinTree結構定義如下： typedef struct TNode *Position; typedef Position BinTree; struct TNode{

第4章第1節練習題11 查詢最近公共祖先節點

問題描述 假設指標p和指標q分別指向二叉樹中任意兩個節點的指標，試編寫演算法找到p和q的最近公共祖先節點r 演算法思想 因為計算的是公共祖先節點，因此可以考慮使用非遞迴後序遍歷的思想。在非遞迴後序遍歷的演算法實現中，棧裡面存放了即將入棧的元素

第4章第1節練習題8 列印指定節點的祖先節點

問題描述 在二叉樹中查詢值為x的節點，試編寫演算法列印值為x的節點的所有祖先節點，假設值為x的節點不多於一個 演算法思想 因為僅僅只是列印祖先節點，可以考慮使用非遞迴後序遍歷的方式來實現。 在非遞迴後序遍歷的方式中，保留在棧中的所有

第4章第1節練習題1 二叉樹的基本操作（遞迴實現）

二叉樹的遞迴遍歷 所謂二叉樹的遍歷，本質上就是沿某條搜尋路徑訪問樹中的每個結點，使得每個節點均被訪問一次，而且僅被訪問一次。 由二叉樹的基本定義可以知道，遍歷一顆二叉樹首先必須決定對根結點(N)，左子樹(L)，右子樹(R)的訪問順序，按照先遍歷左孩子再遍歷右

第1章第1節練習題10 查找中位數

str idt findmi proc borde 1.3 hidden argc -a 問題描寫敘述 一個長度為L(L ≥1) 的升序序列S。處在第 ? L/2 ? 個位置的數稱為S的中位數。比如，若序列S1=(11,13,15,17,19)S

易學筆記-系統分析師考試-第3章 作業系統基本原理/3.4 檔案管理/3.4.1 檔案的組織結構

檔案的組織結構 概念：指的是檔案的構造方式，從使用者角度是檔案的邏輯組織，從系統角度是檔案的物理組織 檔案的邏輯結構 概念：使用者概念中的檔案，不依賴於物理儲存 無結構的流式檔案 指的是資訊項的組合，單位是位元組，系統不

《演算法導論》第四章-第4節_練習（參考答案）

演算法導論（第三版）參考答案：練習4.4-1，練習4.4-2，練習4.4-3，練習4.4-4，練習4.4-5，練習4.4-6，練習4.4-7，練習4.4-8，練習4.4-9 Exercise 4.4-1 Use a reccursion tree

第3章第1節練習題2 回形矩陣

問題描述 回型矩陣即使用二維陣列完成來繞圈圈似的賦值，舉例說明如下所示的形式即為回型陣列。 演算法思想 就單純的在二維陣列中按照某種順序輸出連續的數字而言，實際上是玩弄陣

第1章第1節練習題3 刪除指定元素

問題描述 長度為n的順序表L，編寫一個時間複雜度為O(n)，空間複雜度為O(1)的演算法，該演算法刪除線性表中所有值為e的資料元素 演算法思想1 用k記錄順序表L中不等於e的元素個數

第三章 求1!+1/2!+1/3!+1/4!+....的前20項和

public class Test6{ public static void main(String args[]) { double s=0,a=1,i=1; do{s=s+a; i++; a=(1.0/i)

第2章第2節練習題1 逆置佇列

問題描述 Q是一個佇列，S是一個空棧，實現將佇列中的元素逆置的演算法 演算法思想 因為Q是一個佇列，如果僅僅按照佇列先進先出的特性時無法完成自身元素逆置操作的，而題目中又給出了一個可

第六章（1.4）自然語言處理實戰——時間語義抽取

一、簡介 本工具是由復旦NLP中的時間分析功能修改而來，做了一些細節和功能的優化，經SpringBoot封裝成web工具。 泛指時間的支援，如：早上、晚上、中午、傍晚等。 時間未來傾向。 如：在週五輸入“週一早上開會”，則識別到下週一早上的時間；在下午