2. 程式人生 > 其它 >二叉樹的基本應用（PTA題型為例）

二叉樹的基本應用（PTA題型為例）

阿新 • • 發佈：2021-11-05
二叉樹的遍歷（遞迴與非遞迴，層次），高度，結點求法

我們根據PTA上面的題對於二叉樹有一個更深的認識

7-1 二叉樹的建立和遞迴遍歷 (20 分)

從鍵盤接受輸入擴充套件先序序列，以二叉連結串列作為儲存結構，建立二叉樹。並輸出這棵二叉樹的先序、中序和後序遍歷序列。 二叉樹結點的data是字元型別資料, 其中#表示空格字元。

輸入格式:

輸入擴充套件先序序列。二叉樹結點的data是字元型別資料, 其中#表示空格字元。

輸出格式:

第一行輸出先序遍歷序列；第二行輸出中序遍歷序列；第三行輸出後序遍歷序列。

輸入樣例:

ABC##DE#G##F###

輸出樣例:

ABCDEGF
CBEGDFA
CGEFDBA
//解析：簡單的遞迴實現遍歷 //主要是使用擴充套件先序序列建立二叉樹，本題不過多分析 
#include<stdio.h>
#include
 
<stdlib.h>

typedef struct node{
    char data;
    struct node *Lchild;
    struct node *Rchild;
}BiNode, *BiTree;

//擴充套件先序建立二叉樹
BiTree Creat_Pre_Bitree(BiTree root)
{
    char c;
    c = getchar();
    if(c=='#')
        return NULL;
    else{
        root = (BiTree)malloc(sizeof(BiNode));
        root
 
->data = c;
        root->Lchild = Creat_Pre_Bitree(root->Lchild);
        root->Rchild = Creat_Pre_Bitree(root->Rchild);
    }
    return root;
}
//先序遍歷
void PreOrder(BiTree root)
{
    if(root)
    {
        printf("%c", root->data);
        PreOrder(root->Lchild);
        PreOrder(root
 
->Rchild);
    }
}
//中序遍歷
void InOrder(BiTree root)
{
    if(root){
        InOrder(root->Lchild);
        printf("%c", root->data);
        InOrder(root->Rchild);
    }
}
//後序遍歷
void PostOrder(BiTree root)
{
    if(root){
        PostOrder(root->Lchild);
        PostOrder(root->Rchild);
        printf("%c", root->data);
    }
}

int main()
{
    BiTree root = Creat_Pre_Bitree(&root);
    PreOrder(root);
    printf("\n");
    InOrder(root);
    printf("\n");
    PostOrder(root);
    printf("\n");

    return 0;
}
7-2 非遞迴先序和中序遍歷 (20 分)

從鍵盤接收擴充套件先序序列，以二叉連結串列作為儲存結構，建立二叉樹。採取非遞迴方法輸出這棵二叉樹的先序、中序遍歷序列。

輸入格式:

輸入擴充套件先序序列。二叉樹結點的data是字元型別資料, 其中#表示空格字元。

輸出格式:

第一行輸出先序遍歷序列，第二行輸出中序遍歷序列。

輸入樣例:

ABC##DE#G##F###

輸出樣例:

ABCDEGF
CBEGDFA
//本題主要考察非遞迴的先序和中序遍歷， 演算法實現：大多數的遞迴問題的非遞迴演算法中都需要用棧來消除遞迴 先序遍歷的實現： 1)訪問root，root入棧並進入其左子樹，進而訪問左子樹的root併入棧，在進入下一層左子樹，...直到為空 2)棧非空則從棧頂退出上一層的結點，並進入該節點的右子樹 //棧的基本操作見： 
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
typedef struct node{
    char data;
    struct node *Lchild;
    struct node *Rchild;
}BiNode, *BiTree;

//擴充套件先序建立二叉樹
void Creat_Pre_Bitree(BiTree *root)
{
    char c;
    c = getchar();
    if(c=='#')
        *root = NULL;
    else
    {
        *root = (BiTree)malloc(sizeof(BiNode));
        (*root)->data = c;
        Creat_Pre_Bitree(&((*root)->Lchild));
        Creat_Pre_Bitree(&((*root)->Rchild));
    }
}

/*非遞迴*/
//棧相關
typedef struct {
    BiTree stdata[MaxSize];
    int top;
} sqstack;
//建立棧
sqstack* Init_Stack()
{
    sqstack *s;
    s = (sqstack *)malloc(sizeof(sqstack));
    s->top = -1;
    return s;
}

//判空
int IsEmpty(sqstack *s)
{
    if(s->top==-1)
        return 1;
    else
        return 0;
}

//入棧
void Push(sqstack*s,BiTree root){

    if(s->top<MaxSize){
        s->top++;
        s->stdata[s->top] = root;
        
    }
    return;
}

//出棧
int Pop(sqstack*s,BiTree *x){
    if(IsEmpty(s))
    {
        return 0;
    }
    else
    {
        *x = s->stdata[s->top];
        s->top--;
        return 1;
    }

}
//非遞迴先序
void LPreOrder(BiTree root)
{
    sqstack* s;
    s = Init_Stack();
    BiTree p;
    p = root;
    while(p!=NULL||!IsEmpty(s)){
        while(p!=NULL){
            printf("%c", p->data);
            Push(s, p);
            p = p->Lchild;
        }
        if(!IsEmpty(s)){
            Pop(s,&p);
            p = p->Rchild;
        }
    }

}
//非遞迴中序
void LInOrder(BiTree root)
{
    sqstack* s;
    s = Init_Stack();
    BiTree p = root;
    while(p!=NULL||!IsEmpty(s)){
        while(p!=NULL){
            Push(s, p);
            p = p->Lchild;
        }
        if(!IsEmpty(s)){
            Pop(s,&p);
            printf("%c", p->data);
            p = p->Rchild;
        }
    }

}


int main()
{
    BiTree root;
    Creat_Pre_Bitree(&root);
    LPreOrder(root);
    printf("\n");
    LInOrder(root);
    printf("\n");

    return 0;
}
7-3 非遞迴後序遍歷 (15 分)

從鍵盤接收擴充套件先序序列，以二叉連結串列作為儲存結構，建立二叉樹。採取非遞迴方法輸出這棵二叉樹的後序遍歷序列。

輸入格式:

輸入擴充套件先序序列。二叉樹結點的data是字元型別資料, 其中#表示空格字元。

輸出格式:

輸出後序遍歷序列。

輸入樣例:

ABC##DE#G##F###

輸出樣例:

CGEFDBA
//後序非遞迴不能使用如上先、中序的遍歷方法是因為，當訪問完左右子樹在訪問結點後子樹返回時無法有效的判斷它到底是左子樹返回的還是右子樹返回的，此時我們就需要再加一個判斷 /*演算法實現*/ 1.當前結點進棧，並進入其左子樹，重複至當前結點為空； 2.若棧非空，判斷棧頂結點P的右子樹是否為空，右子樹是否訪問過，是則退棧，訪問p結點，p賦給q，p置空；不是，則進入p的右子樹。 
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
typedef struct node{
    char data;
    struct node *Lchild;
    struct node *Rchild;
}BiNode, *BiTree;

//擴充套件先序建立二叉樹
void Creat_Pre_Bitree(BiTree *root)
{
    char c;
    c = getchar();
    if(c=='#')
        *root = NULL;
    else
    {
        *root = (BiTree)malloc(sizeof(BiNode));
        (*root)->data = c;
        Creat_Pre_Bitree(&((*root)->Lchild));
        Creat_Pre_Bitree(&((*root)->Rchild));
    }
}
/*
//遞迴
void PreOrder(BiTree root)
{
    if(root)
    {
        printf("%c", root->data);
        PreOrder(root->Lchild);
        PreOrder(root->Rchild);
    }
}

void InOrder(BiTree root)
{
    if(root){
        InOrder(root->Lchild);
        printf("%c", root->data);
        InOrder(root->Rchild);
    }
}

void PostOrder(BiTree root)
{
    if(root){
        PostOrder(root->Lchild);
        PostOrder(root->Rchild);
        printf("%c", root->data);
    }
}
*/

/*非遞迴*/
//棧相關
typedef struct {
    BiTree stdata[MaxSize];
    int top;
} sqstack;
//建立棧
sqstack* Init_Stack()
{
    sqstack *s;
    s = (sqstack *)malloc(sizeof(sqstack));
    s->top = -1;
    return s;
}

//判空
int IsEmpty(sqstack *s)
{
    if(s->top==-1)
        return 1;
    else
        return 0;
}

//入棧
void Push(sqstack*s,BiTree root){

    if(s->top<MaxSize){
        s->top++;
        s->stdata[s->top] = root;
        
    }
    return;
}

//出棧
int Pop(sqstack*s,BiTree *x){
    if(IsEmpty(s))
    {
        return 0;
    }
    else
    {
        *x = s->stdata[s->top];
        s->top--;
        return 1;
    }

}
//取棧頂元素
void Top(sqstack*s,BiTree*p)
{
    if(IsEmpty(s))
        return;
    else
        *p = s->stdata[s->top];
}
//非遞迴先序
void LPreOrder(BiTree root)
{
    sqstack* s;
    s = Init_Stack();
    BiTree p;
    p = root;
    while(p!=NULL||!IsEmpty(s)){
        while(p!=NULL){
            printf("%c", p->data);
            Push(s, p);
            p = p->Lchild;
        }
        if(!IsEmpty(s)){
            Pop(s,&p);
            p = p->Rchild;
        }
    }

}
//非遞迴中序
void LInOrder(BiTree root)
{
    sqstack* s;
    s = Init_Stack();
    BiTree p = root;
    while(p!=NULL||!IsEmpty(s)){
        while(p!=NULL){
            Push(s, p);
            p = p->Lchild;
        }
        if(!IsEmpty(s)){
            Pop(s,&p);
            printf("%c", p->data);
            p = p->Rchild;
        }
    }

}
//非遞迴後續遍歷
void LPostOrder(BiTree root)
{
    sqstack *s;
    BiTree p, q;
    s=Init_Stack();
    p = root;
    q = NULL;
    while(p!=NULL||!IsEmpty(s))
    {
        while(p!=NULL)
        {
            Push(s, p);
            p = p->Lchild;
        }
        if(!IsEmpty(s))
        {
            Top(s, &p);
            if((p->Rchild==NULL)||(p->Rchild==q))
            {
                Pop(s, &p);
                printf("%c", p->data);
                q = p;
                p = NULL;
            }
            else
                p = p->Rchild;
        }
    }
}

int main()
{
    BiTree root;
    Creat_Pre_Bitree(&root);
    LPostOrder(root);

    return 0;
}

7-4 層次遍歷 (10 分)

從鍵盤接收擴充套件先序序列，以二叉連結串列作為儲存結構，建立二叉樹。輸出這棵二叉樹的層次遍歷序列。

輸入格式:

輸入擴充套件先序序列。二叉樹結點的data是字元型別資料, 其中#表示空格字元。

輸出格式:

輸出層次遍歷序列。

輸入樣例:

ABC##DE#G##F###

輸出樣例:

ABCDEFG

//二叉樹的層次遍歷 　　所謂二叉樹的層次遍歷就是指從二叉樹的第一層（root結點）開始，自上而下逐層遍歷，同層從左到右逐個訪問。由此我們可知這一訪問過程的特點是：先訪問的結點其孩子也將先訪問，後訪問的結點其孩子也後訪問， 這與佇列的·操作吻合，因此我們用佇列進行節點訪問次序的控制 //演算法實現 1.隊頭結點出隊，並訪問出隊節點 2.出隊結點的非空左、右孩子依次入隊 
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
typedef struct node{
    char data;
    struct node *Lchild;
    struct node *Rchild;
}BiNode, *BiTree;

//擴充套件先序建立二叉樹
void Creat_Pre_Bitree(BiTree *root)
{
    char c;
    c = getchar();
    if(c=='#')
        *root = NULL;
    else
    {
        *root = (BiTree)malloc(sizeof(BiNode));
        (*root)->data = c;
        Creat_Pre_Bitree(&((*root)->Lchild));
        Creat_Pre_Bitree(&((*root)->Rchild));
    }
}

/*queue*/
//迴圈佇列
typedef struct 
{
    BiTree data[MaxSize];
    int front, rear;
}Csqueue;

//置空隊 初始化
Csqueue* Init_Queue()
{
    Csqueue *q;
    q = (Csqueue *)malloc(sizeof(Csqueue));
    q->front = q->rear = MaxSize - 1;
    return q;
}

//入隊
int EnterQueue(Csqueue*q,BiTree x)
{
    if((q->rear+1)%MaxSize==q->front)
    {
        //printf("FULL");
        return 0;
    }
    else
    {
        q->rear = (q->rear + 1) % MaxSize;
        q->data[q->rear] = x;
        return 1; 
    }
}
//出隊
int DelectQueue(Csqueue*q,BiTree*x)
{
    if(q->rear==q->front)
    {
        //printf("NUll");
        return 0;
    }
    else
    {
        q->front = (q->front + 1) % MaxSize;
        *x = q->data[q->front];
        return 1;
    }
}
//判空
int isempty(Csqueue*q)
{
    if(q->front==q->rear)
        return 1;
    return 0;
}

void levelorder(BiTree root)
{
    Csqueue *q;
    BiTree p;
    q = Init_Queue();
    EnterQueue(q, root);
    while(!isempty(q))
    {
        DelectQueue(q, &p);
        printf("%c", root->data);
        if (p->Lchild != NULL)
            EnterQueue(q, p->Lchild);
        if(p->Rchild!=NULL)
            EnterQueue(q, p->Rchild);
    }
}

int main()
{
    BiTree root;
    Creat_Pre_Bitree(&root);
    levelorder(root);
    return 0;
}

7-5 結點個數 (20 分)

從鍵盤接收擴充套件先序序列，以二叉連結串列作為儲存結構，建立二叉樹。分別統計二叉樹中葉子結點、度為1的結點、度為2的結點的個數，並輸出。

輸入格式:

輸入擴充套件先序序列。二叉樹結點的data是字元型別資料, 其中#表示空格字元。

輸出格式:

第一行依次輸出葉子結點個數、度為1的結點個數、度為2的結點個數，以空格隔開。 第二行連續輸出葉子結點，中間不間隔。

輸入樣例:

ABC##DE#G##F###

輸出樣例:

3 2 2
CGF
//結點計算非常簡單，所有node的計算我們只需全部遍歷一遍即可，度數為1的只要判斷左右子樹中有一個存在，另一個為空即可，其他度數的結點演算法一樣 //這裡程式碼我寫的比較多主要是為了能夠將方法儘可能的都複習到，讀者可根據註釋，自行修改！ 
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
typedef struct node{
    char data;
    struct node *Lchild;
    struct node *Rchild;
}BiNode, *BiTree;

//擴充套件先序建立二叉樹
void Creat_Pre_Bitree(BiTree *root)
{
    char c;
    c = getchar();
    if(c=='#')
        *root = NULL;
    else
    {
        *root = (BiTree)malloc(sizeof(BiNode));
        (*root)->data = c;
        Creat_Pre_Bitree(&((*root)->Lchild));
        Creat_Pre_Bitree(&((*root)->Rchild));
    }
}
int count = 0;//node
int onecount = 0;//node = 1
int leafcount = 0;//node = 0

//統計二叉樹中結點數目
/*  
無順序要求，任意遍歷方法均可
*/
void preOrder(BiTree root)
{
    if(root)
    {
        count++;
        preOrder(root->Lchild);
        preOrder(root->Rchild);
    }
}

//統計度數為1的結點
/*
先序（中序、後序均可）如果該節點有左（右）結點，而無右（左）結點，onecount++;
*/
void LfOrder(BiTree root)
{
    if(root)
    {
        if(((root->Lchild==NULL)&&(root->Rchild!=NULL))||((root->Rchild==NULL)&&(root->Lchild!=NULL)))
            onecount++;
        LfOrder(root->Lchild);
        LfOrder(root->Rchild);
    }
}

//統計葉子的結點數目
/*
方法一、使用全域性變數
*/
void LeafOrder(BiTree root)
{
    if(root)
    {
        if((root->Lchild==NULL)&&(root->Rchild==NULL))
        {
            printf("%c", root->data);
        }
        LeafOrder(root->Lchild);
        LeafOrder(root->Rchild);
    }
}
/*
方法二、
採用遞迴思想，如果是空樹，返回0，如果是葉子返回1，狗則，返回左右子樹的葉子結點之和。
重難點：此方法必須在左右子樹的葉子結點求出之後才可求出樹的葉子結點數。所以，我們要選擇後序遍歷
*/
int leaf(BiTree root)
{
    int nl, nr;
    if(root == NULL)
        return 0;
    if((root->Lchild==NULL)&&(root->Rchild==NULL))
         return 1;
    nl = leaf(root->Lchild);
    nr = leaf(root->Rchild);
    return (nl + nr);
}



int main()
{
    BiTree root;
    Creat_Pre_Bitree(&root);
    int n = leaf(root);
    preOrder(root);
    LfOrder(root);
    printf("%d %d %d\n", n, onecount, count - onecount - n);
    LeafOrder(root);
    return 0;
}
7-6 二叉樹的高度 (15 分)

從鍵盤接收擴充套件先序序列，以二叉連結串列作為儲存結構，建立二叉樹。計算二叉樹的高度，並輸出。

輸入格式:

輸入擴充套件先序序列。二叉樹結點的data是字元型別資料, 其中#表示空格字元。

輸出格式:

輸出一個整數。

輸入樣例:

ABC##DE#G##F###

輸出樣例:

5
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
typedef struct node{
    char data;
    struct node *Lchild;
    struct node *Rchild;
}BiNode, *BiTree;
int count=0;
//擴充套件先序建立二叉樹
void Creat_Pre_Bitree(BiTree *root)
{
    char c;
    c = getchar();
    if(c=='#')
        *root = NULL;
    else
    {
        *root = (BiTree)malloc(sizeof(BiNode));
        (*root)->data = c;
        Creat_Pre_Bitree(&((*root)->Lchild));
        Creat_Pre_Bitree(&((*root)->Rchild));
    }
}

/*求二叉樹的高度*/
/**
 * 方法一、使用全域性變數的方法，二叉樹的根節點為第一層的結點，第h曾結點的孩子是h+1
 * 
*/

void Treedepth(BiTree root,int h)
{
    if(root)
    {
        if(h>count)
            count = h;
        Treedepth(root->Lchild, h + 1);
        Treedepth(root->Rchild, h + 1);

    }
}
/*方法二*/
/*
函式值返回：如果是空樹，則高度為0，否則它的高度應為左、右子樹高度的最大值+1，採用後序遍歷

*/
int PostTreedepth(BiTree root)
{
    int hl, hr, h;
    if(root==NULL)
        return 0;
    else
    {
        hl = PostTreedepth(root->Lchild);
        hr = PostTreedepth(root->Rchild);
        h = (hl > hr ? hl : hr) + 1;
        return h;
    }
}

int main()
{
    BiTree root;
    Creat_Pre_Bitree(&root);
    Treedepth(root, 1);
    printf("%d", count);
    return 0;
}

二叉樹的基本應用先到這些，其餘操作以後會慢慢釋出，內容有錯誤，希望大佬指正！！

相關推薦

二叉樹的基本應用（PTA題型為例）

二叉樹的遍歷（遞迴與非遞迴，層次），高度，結點求法 我們根據PTA上面的題對於二叉樹有一個更深的認識

劍指 Offer 27. 二叉樹的映象（遞迴、棧）2

技術標籤：LeetCode 請完成一個函式，輸入一個二叉樹，該函式輸出它的映象。

L2-011 玩轉二叉樹 (25 分)（建樹+後序翻轉）

技術標籤：HBU寒假訓練營演算法二叉樹 給定一棵二叉樹的中序遍歷和前序遍歷，請你先將樹做個鏡面反轉，再輸出反轉後的層序遍歷的序列。所謂鏡面反轉，是指將所有非葉結點的左右孩子對換。這裡假設鍵值都是互不相

LeetCode 543——二叉樹的直徑（深度優先搜尋DFS）

技術標籤：LeetCode刷題 一、題目介紹 給定一棵二叉樹，你需要計算它的直徑長度。一棵二叉樹的直徑長度是任意兩個結點路徑長度中的最大值。這條路徑可能穿過也可能不穿過根結點。

資料結構之二叉樹——遍歷（遞迴與非遞迴）

定義 二叉樹，一個有窮的結點集合。這個集合可以為空，如果不為空，則它是由根結點和稱其為左子樹和右子樹的兩個不相交的二叉樹組成。

二叉樹--驗證BST（leetcode 98）

知識點 BST的整個左子樹中所有元素的值都是要小於根的值 BST的整個右子樹中所有元素的值都是要大於根的值

《演算法筆記》7. 二叉樹基本演算法整理

目錄1 二叉樹基本演算法1.1 二叉樹的遍歷1.1.1 二叉樹節點定義1.1.2 遞迴實現先序中序後序遍歷1.1.3 非遞迴實現先序中序後序遍歷1.1.4 二叉樹按層遍歷1.2 二叉樹的序列化和反序列化1.3 直觀列印一顆二叉樹1.4 題目實

二叉數的中序遍歷原理及例題Leetcode（94. 二叉樹的中序遍歷 c++實現）

1.中序遍歷 中序遍歷的步驟為 : 遍歷左孩子--> 遍歷根節點-->遍歷右孩子 如上圖，這顆樹由5個節點，A，B，C，D，E組成。其中a為根節點 ，b為左子樹，cde為右子樹

實驗7、二叉樹的應用

技術標籤：二叉樹java -（1）實驗目的 通過該實驗，使學生理解二叉樹的鏈式儲存，掌握二叉樹的幾種遍歷演算法，並通過該實驗使學生理解遞迴的含義，掌握C語言編寫遞迴函式的方法和注意事項。

二叉樹基本操作

技術標籤：資料結構資料結構二叉樹 二叉樹基礎操作 求二叉樹的建立、遍歷、葉子結點個數、樹的深度

劍指 Offer 07. 重建二叉樹 - 力扣（LeetCode）

技術標籤：劍指offerleetcode演算法hashmap 重建二叉樹 解法一: 時間空間複雜度雙高 應該是因為使用了Arrays.copyOfRange()函式導致的 新思路 不傳入陣列 改為傳入陣列下標 ===>解法二

力扣刷題筆記：劍指 Offer 27. 二叉樹的映象（利用臨時列表遍歷樹的所有節點 node ，並交換每個 node 的左 / 右子節點。）

技術標籤：刷題筆記leetcodepython 題目： 劍指 Offer 27、二叉樹的映象 請完成一個函式，輸入一個二叉樹，該函式輸出它的映象。

LeetCode 563——二叉樹的坡度（DFS）

技術標籤：LeetCode刷題 一、題目介紹 給定一個二叉樹，計算 整個樹 的坡度 。

《資料結構》樹和二叉樹程式碼整理（C語言實現）

二叉搜尋樹--遞迴--插入，刪除，和查詢 1 //二叉查詢樹遞迴實現插入，刪除和查詢

劍指 Offer 27. 二叉樹的映象（簡單）

通過率79.0% 題目連結 題目描述： 請完成一個函式，輸入一個二叉樹，該函式輸出它的映象。

LeetCode——563. 二叉樹的坡度（Java）

題目描述 題幹: 給定一個二叉樹，計算 整個樹 的坡度 。 一個樹的 節點的坡度 定義即為，該節點左子樹的節點之和和右子樹節點之和的 差的絕對值 。

二叉樹基本操作(層序、先序建立，遍歷方式等)

關於樹的操作，大部分都是使用遞迴的思想。只有層序構建二叉樹時需要注意一下，它通過使用佇列的方式記錄每一個節點，當一個節點有孩子節點時，就將孩子節點新增到佇列中。當佇列為空時，則說明二叉樹建立完畢。具體

分治法在二叉樹的應用

分治法在二叉樹的應用 二叉樹 每個節點最多有兩個子樹的樹結構。 二叉樹的高度：

二叉樹----二叉樹基本概念

二叉樹（binary tree,簡寫成BT）是一種特殊的樹型結構，它的度數為2的樹。即二叉樹的每個結點最多有兩個子結點。每個結點的子結點分別稱為左孩子、右孩子，它的兩棵子樹分別稱為左子樹、右子樹。二叉樹有5中基本形態

二叉樹基本概念

二叉樹 簡單概念：根節點、子樹、葉子節點 父節點、兄弟節點、孩子節點（左孩子、右孩子）