04-樹7 二叉搜尋樹的操作集 (30分)

阿新 • • 發佈：2020-08-02

本題要求實現給定二叉搜尋樹的5種常用操作。

函式介面定義：

BinTree Insert( BinTree BST, ElementType X );
BinTree Delete( BinTree BST, ElementType X );
Position Find( BinTree BST, ElementType X );
Position FindMin( BinTree BST );
Position FindMax( BinTree BST );

其中BinTree結構定義如下：

typedef struct TNode *Position;
typedef Position BinTree;
 
struct TNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

函式Insert將X插入二叉搜尋樹BST並返回結果樹的根結點指標；
函式Delete將X從二叉搜尋樹BST中刪除，並返回結果樹的根結點指標；如果X不在樹中，則列印一行Not Found並返回原樹的根結點指標；
函式Find在二叉搜尋樹BST中找到X，返回該結點的指標；如果找不到則返回空指標；
函式FindMin返回二叉搜尋樹BST中最小元結點的指標；
函式FindMax返回二叉搜尋樹BST中最大元結點的指標。

裁判測試程式樣例：

#include <stdio.h>
#include  
<stdlib.h>

typedef int ElementType;
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

void PreorderTraversal( BinTree BT ); /* 先序遍歷，由裁判實現，細節不表 */
void InorderTraversal( BinTree BT );  /* 中序遍歷，由裁判實現，細節不表 */

BinTree Insert( BinTree BST, ElementType X );
BinTree Delete( BinTree BST, ElementType X );
Position Find( BinTree BST, ElementType X );
Position FindMin( BinTree BST );
Position FindMax( BinTree BST );

 
int main()
{
    BinTree BST, MinP, MaxP, Tmp;
    ElementType X;
    int N, i;

    BST = NULL;
    scanf("%d", &N);
    for ( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Insert(BST, X);
    }
    printf("Preorder:"); PreorderTraversal(BST); printf("\n");
    MinP = FindMin(BST);
    MaxP = FindMax(BST);
    scanf("%d", &N);
    for( i=0; i<N; i++ ) {
        scanf("%d", &X);
        Tmp = Find(BST, X);
        if (Tmp == NULL) printf("%d is not found\n", X);
        else {
            printf("%d is found\n", Tmp->Data);
            if (Tmp==MinP) printf("%d is the smallest key\n", Tmp->Data);
            if (Tmp==MaxP) printf("%d is the largest key\n", Tmp->Data);
        }
    }
    scanf("%d", &N);
    for( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Delete(BST, X);
    }
    printf("Inorder:"); InorderTraversal(BST); printf("\n");

    return 0;
}
/* 你的程式碼將被嵌在這裡 */

輸入樣例：

10
5 8 6 2 4 1 0 10 9 7
5
6 3 10 0 5
5
5 7 0 10 3

輸出樣例：

Preorder: 5 2 1 0 4 8 6 7 10 9
6 is found
3 is not found
10 is found
10 is the largest key
0 is found
0 is the smallest key
5 is found
Not Found
Inorder: 1 2 4 6 8 9

提交測試程式碼：

BinTree Insert(BinTree BST, ElementType X) {
    if (!BST) {
        BST = (BinTree)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = NULL;
        BST->Right = NULL;
    }
    else if (BST->Data > X) {
        BST->Left = Insert(BST->Left, X);
    }
    else if (BST->Data < X) {
        BST->Right = Insert(BST->Right, X);
    }
    return BST;
}

BinTree Delete(BinTree BST, ElementType X) {
    if (!BST) {
        printf("Not Found\n");
    }
    else if (BST->Data > X) {
        BST->Left = Delete(BST->Left, X);
    }
    else if (BST->Data < X) {
        BST->Right = Delete(BST->Right, X);
    }
    else if (BST->Left != NULL && BST->Right == NULL) {
        BinTree tmp = BST;
        BST = BST->Left;
        free(tmp);
    }
    else if (BST->Left == NULL && BST->Right != NULL) {
        BinTree tmp = BST;
        BST = BST->Right;
        free(tmp);
    }
    else if (BST->Left == NULL && BST->Right == NULL) {
        free(BST);
        BST = NULL;
    }
    else {
        Position tmp = FindMin(BST->Right);
        BST->Data = tmp->Data;
        BST->Right = Delete(BST->Right, BST->Data);
    }
    return BST;
}

Position Find(BinTree BST, ElementType X) {
    if (!BST) {
        return NULL;
    }
    else if (BST->Data > X) {
        return Find(BST->Left, X);
    }
    else if (BST->Data < X) {
        return Find(BST->Right, X);
    }
    else {
        return BST;
    }
}

Position FindMin(BinTree BST)
{
    if (!BST)
    {
        return NULL;
    }
    else if (BST->Left != NULL) {
        return FindMin(BST->Left);
    }
    else {
        return BST;
    }
}

Position FindMax(BinTree BST)
{
    if (!BST) {
        return NULL;
    }
    else if (BST->Right != NULL) {
        return FindMax(BST->Right);
    }
    else {
        return BST;
    }
}

提測結果：

完整自測程式碼：

#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode {
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

void PreorderTraversal(BinTree BT); /* 先序遍歷，由裁判實現，細節不表 */
void InorderTraversal(BinTree BT);  /* 中序遍歷，由裁判實現，細節不表 */

BinTree Insert(BinTree BST, ElementType X);
BinTree Delete(BinTree BST, ElementType X);
Position Find(BinTree BST, ElementType X);
Position FindMin(BinTree BST);
Position FindMax(BinTree BST);

int main()
{
    BinTree BST, MinP, MaxP, Tmp;
    ElementType X;
    int N, i;

    BST = NULL;
    scanf("%d", &N);
    for (i = 0; i < N; i++) {
        scanf("%d", &X);
        BST = Insert(BST, X);
    }
    printf("Preorder:"); PreorderTraversal(BST); printf("\n");
    MinP = FindMin(BST);
    MaxP = FindMax(BST);
    scanf("%d", &N);
    for (i = 0; i < N; i++) {
        scanf("%d", &X);
        Tmp = Find(BST, X);
        if (Tmp == NULL) printf("%d is not found\n", X);
        else {
            printf("%d is found\n", Tmp->Data);
            if (Tmp == MinP) printf("%d is the smallest key\n", Tmp->Data);
            if (Tmp == MaxP) printf("%d is the largest key\n", Tmp->Data);
        }
    }
    scanf("%d", &N);
    for (i = 0; i < N; i++) {
        scanf("%d", &X);
        BST = Delete(BST, X);
    }
    printf("Inorder:"); InorderTraversal(BST); printf("\n");

    return 0;
}

void PreorderTraversal(BinTree T){
    if (!T) {
        return;
    }
    printf(" %d", T->Data);
    if(T->Left){
        PreorderTraversal(T->Left);
    }
    if (T->Right){
        PreorderTraversal(T->Right);
    }
}

void InorderTraversal(BinTree T)
{
    if (!T) {
        return;
    }
    if (T->Left) {
        InorderTraversal(T->Left);
    }
    printf(" %d", T->Data);
    if (T->Right) {
        InorderTraversal(T->Right);
    }
}

BinTree Insert(BinTree BST, ElementType X) {
    if (!BST) {
        BST = (BinTree)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = NULL;
        BST->Right = NULL;
    }
    else if (BST->Data > X) {
        BST->Left = Insert(BST->Left, X);
    }
    else if (BST->Data < X) {
        BST->Right = Insert(BST->Right, X);
    }
    return BST;
}

BinTree Delete(BinTree BST, ElementType X) {
    if (!BST) {
        printf("Not Found\n");
    }
    else if (BST->Data > X) {
        BST->Left = Delete(BST->Left, X);
    }
    else if (BST->Data < X) {
        BST->Right = Delete(BST->Right, X);
    }
    else if (BST->Left != NULL && BST->Right == NULL) {
        BinTree tmp = BST;
        BST = BST->Left;
        free(tmp);
    }
    else if (BST->Left == NULL && BST->Right != NULL) {
        BinTree tmp = BST;
        BST = BST->Right;
        free(tmp);
    }
    else if (BST->Left == NULL && BST->Right == NULL) {
        free(BST);
        BST = NULL;
    }
    else {
        Position tmp = FindMin(BST->Right);
        BST->Data = tmp->Data;
        BST->Right = Delete(BST->Right, BST->Data);
    }
    return BST;
}

Position Find(BinTree BST, ElementType X) {
    if (!BST) {
        return NULL;
    }
    else if (BST->Data > X) {
        return Find(BST->Left, X);
    }
    else if (BST->Data < X) {
        return Find(BST->Right, X);
    }
    else {
        return BST;
    }
}

Position FindMin(BinTree BST)
{
    if (!BST)
    {
        return NULL;
    }
    else if (BST->Left != NULL) {
        return FindMin(BST->Left);
    }
    else {
        return BST;
    }
}

Position FindMax(BinTree BST)
{
    if (!BST) {
        return NULL;
    }
    else if (BST->Right != NULL) {
        return FindMax(BST->Right);
    }
    else {
        return BST;
    }
}

04-樹7 二叉搜尋樹的操作集 (30分)

本題要求實現給定二叉搜尋樹的5種常用操作。函式介面定義： BinTree Insert( BinTree BST, ElementType X );

LeetCode 樹 98. 驗證二叉搜尋樹（二叉搜尋樹，遞迴，中序遍歷，迭代）

中序。剛拿到題目時，第一想法是遞迴，但是搞錯了二叉搜尋樹成立的條件。

【LeetCode-樹】二叉搜尋樹與雙向連結串列

題目描述輸入一棵二叉搜尋樹，將該二叉搜尋樹轉換成一個排序的迴圈雙向連結串列。要求不能建立任何新的節點，只能調整樹中節點指標的指向。

【LeetCode-樹】二叉搜尋樹的最近公共祖先

題目描述給定一個二叉搜尋樹, 找到該樹中兩個指定節點的最近公共祖先。百度百科中最近公共祖先的定義為：“對於有根樹 T 的兩個結點 p、q，最近公共祖先表示為一個結點 x，滿足 x 是 p、q 的祖先且 x 的深度儘可能

【LeetCode-樹】二叉搜尋樹的後序遍歷序列

題目描述輸入一個整數陣列，判斷該陣列是不是某二叉搜尋樹的後序遍歷結果。如果是則返回 true，否則返回 false。假設輸入的陣列的任意兩個數字都互不相同。

二叉排序樹（二叉搜尋樹、二叉查詢樹）BST

概述對於一組元素 [7, 3, 10, 12, 5, 1, 9] 可以有很多種儲存方式，但無論使用哪種資料結構，都或多或少有缺陷。比如使用線性結構儲存，排序方便，但查詢效率低。二叉排序樹的特點就是能在保證元素有序的同時，提高

【40講系列5】二叉樹、二叉搜尋樹

一、理論二、典型例題 ☆☆①：驗證二叉搜尋樹（LC98）思路：中序遍歷時，判斷當前節點是否大於中序遍歷的前一個節點，如果大於，滿足BST，繼續遍歷；否則返回false。

演算法--樹10.二叉搜尋樹的第k個結點

技術標籤：演算法二叉樹演算法返回二叉搜尋樹的第k個節點中序遍歷是從小到大的，返回第k個就行

c/c++補完計劃(五):平衡二叉樹和二叉搜尋樹

技術標籤：c++c++資料結構目錄前言平衡二叉樹判斷自頂向下自底向上二叉搜尋樹的最近公共祖先最後

演算法與資料結構-樹-簡單-二叉搜尋樹中的眾數

二叉搜尋樹中的眾數題目 leetcode原題：501. 二叉搜尋樹中的眾數給定一個有相同值的二叉搜尋樹（BST），找出 BST 中的所有眾數（出現頻率最高的元素）。

【LeetCode】C++ ：簡單題 - 樹 235. 二叉搜尋樹的最近公共祖先

技術標籤：LeetCodeleetcode演算法二叉樹 235. 二叉搜尋樹的最近公共祖先難度簡單511

二叉排序樹（二叉搜尋樹）

技術標籤：演算法與資料結構二叉排序樹二叉搜尋樹二叉樹java資料結構一、二叉排序樹概述

【LeetCode】C++ ：中等題 - 樹 173. 二叉搜尋樹迭代器

技術標籤：LeetCode# 樹leetcode演算法二叉樹 173. 二叉搜尋樹迭代器難度中等322 實現一個二叉搜尋樹迭代器。你將使用二叉搜尋樹的根節點初始化迭代器。

二叉樹和二叉搜尋樹

二叉樹遍歷 class Bitree: def __init__(self, data): self.data = data self.lchild = None self.rchild = None

資料結構~基礎2~樹【《二叉樹、二叉搜尋樹、AVL樹、B樹、紅黑樹》的設計】~二叉樹

Java二叉搜尋樹遍歷操作詳解【前序、中序、後序、層次、廣度優先遍歷】

本文例項講述了Java二叉搜尋樹遍歷操作。分享給大家供大家參考，具體如下：

LeetCode | 0701. Insert into a Binary Search Tree 二叉搜尋樹中的插入操作【Python】

LeetCode 0701. Insert into a Binary Search Tree 二叉搜尋樹中的插入操作【Medium】【Python】【二叉樹】

二叉搜尋樹的操作集

函式介面定義：函式Insert將X插入二叉搜尋樹BST並返回結果樹的根結點指標；函式Delete將X從二叉搜尋樹BST中刪除，並返回結果樹的根結點指標；如果X不在樹中，則列印一行Not Found並返回原樹的根結點指標；

96. 不同的二叉搜尋樹-7月15日

題目 96. 不同的二叉搜尋樹我的思路很自然想到二叉搜尋樹的根的左右又是兩個二叉搜尋樹，所以以某個值作為總數跟的二叉搜尋樹的種類為它左右兩個子二叉樹的各自種類之乘積。

04-樹4 是否同一棵二叉搜尋樹 (25分)

04-樹4是否同一棵二叉搜尋樹(25分) 給定一個插入序列就可以唯一確定一棵二叉搜尋樹。然而，一棵給定的二叉搜尋樹卻可以由多種不同的插入序列得到。例如分別按照序列{2, 1, 3}和{2, 3, 1}插入初始為空的二叉搜尋

04-樹7 二叉搜尋樹的操作集 (30分)

函式介面定義：

裁判測試程式樣例：

輸入樣例：

輸出樣例：

相關推薦