資料結構——二叉排序樹

阿新 • • 發佈：2018-12-02

建立、查詢、刪除

codeblocks 17 通過

#include <iostream>
#define KeyType int
#define InfoType char
using namespace std;

typedef struct
{
    KeyType key;    // 關鍵字項
    InfoType otherinfo;  // 其他資料項
}ElemType;  // 每個節點的資料型別
typedef struct BSTNode
{
    ElemType data;  // 節點的資料項
    struct BSTNode *lchild, *rchild;
}BSTNode,*BSTree;

void InsertBST(BSTree &T, ElemType e)
{
    if(!T)  // T根節點為空
    {
        BSTree S = new BSTNode;
        S->data = e;
        S->lchild = S->rchild = NULL;
        T=S;
    }
    else if(e.key < T->data.key)
        InsertBST(T->lchild,e);
    else if(e.key > T->data.key)
        InsertBST(T->rchild,e);
}

void CreateBSTree(BSTree &T)
{
    T = NULL;   // 初始化為空樹
    int n=15;
    //cin>>n:
    while(n>0)
    {
        ElemType value;
        cin>>value.key;
        InsertBST(T,value);
        n--;
    }
    //cout<<"Create Done !"<<endl;
}

BSTree SearchBST(BSTree &T, KeyType key)
{
    if((!T)||key==T->data.key)
        return T;   // 查詢結束 返回目標節點或者空指標
    else if(key<T->data.key)
        return SearchBST(T->lchild,key);    // 在左子樹中繼續查詢
    else
        return SearchBST(T->rchild,key);    // 在右子樹中繼續查詢
}

void InOrderTraverse(BSTree T)
{// 中序遞迴遍歷
    if(T)
    {
        InOrderTraverse(T->lchild);
        cout<<T->data.key<<" ";
        InOrderTraverse(T->rchild);
    }
}

void DeleteBST(BSTree &T, KeyType key)
{// 從二叉排序樹T中刪除關鍵字等於key的節點
    BSTree p = T, f=NULL, q;    // 初始化
    /*------下面的while迴圈從根開始查詢關鍵字等於key的節點--------*/
    while(p)
    {
        if(p->data.key == key)
            break;
        f = p;
        if(p->data.key > key)
            p = p->lchild;
        else
            p = p->rchild;
    }
    /*--------分別考慮三種情況，p所指的子樹內部：左右子樹都不為空，無左子樹，無右子樹---------*/
    q = p;
    if((p->lchild)&&(p->rchild))    // 左右子樹都不為空
    {
        BSTree s = p->lchild;
        while(s->rchild)    // 查詢p的左子樹的最右節點，即p的直接前驅
        {
            q=s;s=s->rchild;
        }
        p->data=s->data;    // 將s的data 賦值給要刪除的節點p，p不能直接delete，需要保持p的左右子樹關係
        if(q!=p)    // 如果pq不相同，說明s有右子樹
            q->rchild=s->lchild;
        else    // qp相同，說明s沒有右子樹
            q->lchild=s->lchild;
        delete s;
        return; // 刪除結束！！！
    }
    else if(!p->rchild)   // 無右子樹，只需要重接左子樹
    {
        p = p->lchild;
    }
    else if(!p->lchild)   // 無左子樹，只需要重接右子樹
    {
        p = p->rchild;
    }
    /*-------將p所指的子樹掛接到其雙親節點*f相應位置-----------*/
    if(!f)  T=p;    // 如果刪除的是根節點
    else if(q==f->lchild)   //  q是f的左子樹，p接到f的左子樹位置
        f->lchild=p;
    else    // q是f的右子樹，p接到f的右子樹位置
        f->rchild=p;
    delete q;
}

int main()
{
    BSTree T;
    CreateBSTree(T);
    InOrderTraverse(T);
    cout<<"\n";
    BSTree p;
    KeyType key;
    cin>>key;
    p = SearchBST(T,key);
    if(p)
        cout<<"查詢成功！"<<endl;
    else
        cout<<"not find it!"<<endl;
    cin>>key;
    DeleteBST(T,key);
    InOrderTraverse(T);

}


/*
test data：
輸入：
1 5 4 2 3 6 8 7 9 11 14 13 12 16 19
輸出：
1 2 3 4 5 6 7 8 9 11 12 13 14 16 19
輸入：
19
輸出：
查詢成功！
輸入：
14
輸出：
1 2 3 4 5 6 7 8 9 11 12 13 19 16

*/

附圖便於思考刪除演算法

小甲魚老師的程式碼，我加了註釋：

int Delete(BSTree &p)
{
    BSTree q, s;
    /*-----待刪除的節點只有左或右子樹----*/
    if(p->rchild == NULL)
    {
        q = p;
        p = p->lchild;
        delete q;
    }
    else if(p->lchild == NULL)
    {
        q = p;
        p = p->rchild;
        delete q;
    }
    /*-----待刪除的節點有左和右子樹-------*/
    else
    {
        q = p;
        s = p->lchild;

        while(s->rchild)
        {// 查詢p的直接前驅，s記錄，q是s的雙親
            q = s;
            s = s->rchild;
        }

        p->data.key = s->data.key;  // 資料替換

        if(q != p)  // qp不想同，說明p的左子樹有右子樹
            q->rchild = s->lchild;
       else // qp相同，說明p的左子樹沒有右子樹
            q->lchild = s->lchild;

       delete s;
    }

    return 1;
}
int DeleteBST_JiaYu(BSTree &T, KeyType key)
{// 返回刪除結果,該函式也可通過呼叫search函式進行查詢，再刪除。
    if(!T)
        return -1;
    else
    {
        if(key == T->data.key)
            return Delete(T);
        else if(key>T->data.key)
            return DeleteBST_JiaYu(T->rchild,key);
        else
            return DeleteBST_JiaYu(T->lchild,key);
    }
}

另附圖：

完整程式碼code

// 二叉排序樹 @ChenYe 2018/12/02
#include <iostream>
#define KeyType int
#define InfoType char
using namespace std;

typedef struct
{
    KeyType key;    // 關鍵字項
    InfoType otherinfo;  // 其他資料項
}ElemType;  // 每個節點的資料型別
typedef struct BSTNode
{
    ElemType data;  // 節點的資料項
    struct BSTNode *lchild, *rchild;
}BSTNode,*BSTree;

void InsertBST(BSTree &T, ElemType e)
{
    if(!T)  // T根節點為空
    {
        BSTree S = new BSTNode;
        S->data = e;
        S->lchild = S->rchild = NULL;
        T=S;
    }
    else if(e.key < T->data.key)
        InsertBST(T->lchild,e);
    else if(e.key > T->data.key)
        InsertBST(T->rchild,e);
}

void CreateBSTree(BSTree &T)
{
    T = NULL;   // 初始化為空樹
    int n=15;
    //cin>>n:
    while(n>0)
    {
        ElemType value;
        cin>>value.key;
        InsertBST(T,value);
        n--;
    }
    //cout<<"Create Done !"<<endl;
}

BSTree SearchBST(BSTree &T, KeyType key)
{
    if((!T)||key==T->data.key)
        return T;   // 查詢結束 返回目標節點或者空指標
    else if(key<T->data.key)
        return SearchBST(T->lchild,key);    // 在左子樹中繼續查詢
    else
        return SearchBST(T->rchild,key);    // 在右子樹中繼續查詢
}

void InOrderTraverse(BSTree T)
{// 中序遞迴遍歷
    if(T)
    {
        InOrderTraverse(T->lchild);
        cout<<T->data.key<<" ";
        InOrderTraverse(T->rchild);
    }
}

void DeleteBST(BSTree &T, KeyType key)
{// 從二叉排序樹T中刪除關鍵字等於key的節點
    BSTree p = T, f=NULL, q;    // 初始化
    /*------下面的while迴圈從根開始查詢關鍵字等於key的節點--------*/
    while(p)
    {
        if(p->data.key == key)
            break;
        f = p;
        if(p->data.key > key)
            p = p->lchild;
        else
            p = p->rchild;
    }
    /*--------分別考慮三種情況，p所指的子樹內部：左右子樹都不為空，無左子樹，無右子樹---------*/
    q = p;
    if((p->lchild)&&(p->rchild))    // 左右子樹都不為空
    {
        BSTree s = p->lchild;
        while(s->rchild)    // 查詢p的左子樹的最右節點，即p的直接前驅
        {
            q=s;s=s->rchild;
        }
        p->data=s->data;    // 將s的data 賦值給要刪除的節點p，p不能直接delete，需要保持p的左右子樹關係
        if(q!=p)    // 如果pq不相同，說明s有右子樹
            q->rchild=s->lchild;
        else    // qp相同，說明s沒有右子樹
            q->lchild=s->lchild;
        delete s;
        return; // 刪除結束！！！
    }
    else if(!p->rchild)   // 無右子樹，只需要重接左子樹
    {
        p = p->lchild;
    }
    else if(!p->lchild)   // 無左子樹，只需要重接右子樹
    {
        p = p->rchild;
    }
    /*-------將p所指的子樹掛接到其雙親節點*f相應位置-----------*/
    if(!f)  T=p;    // 如果刪除的是根節點
    else if(q==f->lchild)   //  q是f的左子樹，p接到f的左子樹位置
        f->lchild=p;
    else    // q是f的右子樹，p接到f的右子樹位置
        f->rchild=p;
    delete q;
}

int Delete(BSTree &p)
{
    BSTree q, s;
    /*-----待刪除的節點只有左或右子樹----*/
    if(p->rchild == NULL)
    {
        q = p;
        p = p->lchild;
        delete q;
    }
    else if(p->lchild == NULL)
    {
        q = p;
        p = p->rchild;
        delete q;
    }
    /*-----待刪除的節點有左和右子樹-------*/
    else
    {
        q = p;
        s = p->lchild;

        while(s->rchild)
        {// 查詢p的直接前驅，s記錄，q是s的雙親
            q = s;
            s = s->rchild;
        }

        p->data.key = s->data.key;  // 資料替換

        if(q != p)  // qp不想同，說明p的左子樹有右子樹
            q->rchild = s->lchild;
       else // qp相同，說明p的左子樹沒有右子樹
            q->lchild = s->lchild;

       delete s;
    }

    return 1;
}
int DeleteBST_JiaYu(BSTree &T, KeyType key)
{// 返回刪除結果,該函式也可通過呼叫search函式進行查詢，再刪除。
    if(!T)
        return -1;
    else
    {
        if(key == T->data.key)
            return Delete(T);
        else if(key>T->data.key)
            return DeleteBST_JiaYu(T->rchild,key);
        else
            return DeleteBST_JiaYu(T->lchild,key);
    }
}


int main()
{
    BSTree T;
    CreateBSTree(T);
    InOrderTraverse(T);
    cout<<"\n";
    BSTree p;
    KeyType key;
    cin>>key;
    p = SearchBST(T,key);
    if(p)
        cout<<"查詢成功！"<<endl;
    else
        cout<<"not find it!"<<endl;
    cin>>key;
    DeleteBST(T,key);
    InOrderTraverse(T);


    cout<<"\n新增測試，請輸入要刪除的資料：\n";
    cin>>key;
    DeleteBST_JiaYu(T,key);
    InOrderTraverse(T);

}


/*
test data：
輸入：
1 5 4 2 3 6 8 7 9 11 14 13 12 16 19
輸出：
1 2 3 4 5 6 7 8 9 11 12 13 14 16 19
輸入：
19
輸出：
查詢成功！
輸入：
14
輸出：
1 2 3 4 5 6 7 8 9 11 12 13 19 16

*/

測試

資料結構——二叉排序樹

建立、查詢、刪除 codeblocks 17 通過 #include <iostream> #define KeyType int #define InfoType char using namespace std; typedef struct { KeyType k

資料結構----二叉排序樹

結點結構 /**********結點結構*********/ typedef struct BTNode { int key; struct BTNode *lchild; struct BTN

資料結構二叉排序樹操作及實現

#include<iostream> #include<cstdio> #include<cstdlib> #include<cstring> using namespace std; typedef struct Bitn

資料結構---二叉搜尋樹BST實現（C++）

1. 二叉查詢樹二叉查詢樹（Binary Search Tree），也稱為二叉搜尋樹、有序二叉樹（ordered binary tree）或排序二叉樹（sorted binary tree），是指一棵空樹或者具有下列性質的二叉樹：若任意節點的左子樹不空，則左子樹上所有節點的值均小於它的根節點的值

C資料結構-二叉搜尋樹BSTree

二叉搜尋樹BSTree #ifndef BSTREE_H #define BSTREE_H #ifndef NULL #define NULL 0 #endif /* 元素型別 */ typedef int elem_t; /* 節點結構體 */ typedef struc

Python資料結構——二叉搜尋樹的實現（下）

搜尋樹實現（續）最後，我們把注意力轉向二叉搜尋樹中最具挑戰性的方法，刪除一個鍵值（參見Listing 7）。首要任務是要找到搜尋樹中要刪除的節點。如果樹有一個以上的節點，我們使用_get方法找到需要刪除的節點。如果樹只有一個節點，這意味著我們要刪除樹的根，但是我們仍然要檢查根的鍵值是否與要刪除的鍵值匹配。

資料結構: 二叉搜尋樹

二叉搜尋樹二叉查詢樹（Binary Search Tree），也稱二叉搜尋樹、有序二叉樹（ordered binary tree），排序二叉樹（orted binary tree）特點: 二叉樹若任意節點的左子樹不空,則左子樹上所有節點的值均小於

資料結構——二叉查詢樹的詳細實現(c++)

本文實現了二叉查詢樹的前序遍歷（遞迴與非遞迴）、中序遍歷（遞迴與非遞迴）、後序遍歷（遞迴與非遞迴）、插入過程、刪除過程、查詢過程等。二叉樹的簡單介紹： 1、二叉樹中的每個節點都不能有多餘兩個的兒子。 2、二叉樹的深度要比N小得多。假設每個節點被指

Python資料結構——二叉搜尋樹的實現（上）

二叉搜尋樹我們已經知道了在一個集合中獲取鍵值對的兩種不同的方法。回憶一下這些集合是如何實現ADT（抽象資料型別）MAP的。我們討論兩種ADT MAP的實現方式，基於列表的二分查詢和雜湊表。在這一節中，我們將要學習二叉搜尋樹，這是另一種鍵指向值的Map集合，在這種情況下我們不用

C++資料結構——二叉搜尋樹（實現自定義迭代器）

#ifndef BS_Tree_H #define BS_Tree_H #include"node.h" #include<iostream> #include<queue> using namespace std; template<typename T>class

資料結構作業：二叉排序樹及其相關操作

寫了一個簡單的。因為自己對泛型瞭解的還是不夠到位，所以只能寫個demo版的。這課樹沒辦法維持平衡，希望以後學一下紅黑樹，替罪羊樹etc. /* * 簡單的二叉查詢樹 * 沒有自帶旋轉平衡 * 寫完這個我學一下 * avl樹還有紅黑樹 */ public c

Python資料結構——二叉樹排序

二叉排序樹的過程主要是：二叉樹的構建和遍歷。當樹構建好後，對樹進行中序遍歷（左中右），即可得到，對資料從小到大排序的結果。如果對樹進行“右中左遍歷”，則可以得到，對資料從大到小排序的結果 # -*- coding:utf-8 -*- # file: pySort.py #

Android版資料結構與演算法(八)：二叉排序樹

本文目錄前兩篇文章我們學習了一些樹的基本概念以及常用操作，本篇我們瞭解一下二叉樹的一種特殊形式：二叉排序樹（Binary Sort Tree），又稱二叉查詢樹（Binary Search Tree），亦稱二叉搜尋樹。一、二叉排序樹定義二叉排序樹或者是一顆空樹，或者是具有下列性質的二叉樹：

java資料結構之二叉排序樹

binary sort tree / binary search tree 性質： 1.若左子樹不為空，則左子樹上所有節點的值均小於它的根節點的值。 2.若右子樹不為空，則右子樹上所有節點的值均大於它的根節點的值。 3.左右子樹也是二叉排序樹。 4.沒有值相同的節點

資料結構圖文解析之：樹的簡介及二叉排序樹C++模板實現.

閱讀目錄 0. 資料結構圖文解析系列 1. 樹的簡介 1.1 樹的特徵 1.2 樹的相關概念 2. 二叉樹簡介 2.1 二叉樹的定義 2.2 斜樹、滿二叉樹、完全二叉樹、二叉查詢樹 2

資料結構實驗之查詢一：二叉排序樹（SDUT 3373）

二叉排序樹（Binary Sort Tree），又稱二叉查詢樹（Binary Search Tree），也稱二叉搜尋樹。 #include <stdio.h> #include <string.h> #include <stdlib.h> struct nod

資料結構之二叉排序樹

上一節我們介紹了二分（折半）查詢，也瞭解了它的優缺點。二分查詢的特點:二分查詢能夠提高有序表中資料元素的查詢速度；二分查詢的時間複雜度為O(log2n)；二分查詢是一種靜態查詢二分查詢的不足：當查詢表經常變化時，二分查詢的整體效能急劇下降。二分查詢的硬傷：二分查詢基於有序表。

Java資料結構：二叉排序樹的刪除操作

嚶嚶嚶，今天補回昨天沒有寫的部落格。二叉排序樹的刪除操作比較簡單，但是思想很全面，因此本人就寫一篇部落格紀念一下。思想：四種類型也可以是三種 1，刪除結點p的度為2，即有左右子樹。此時有兩種方法，第一種將結點的左子樹在中根遍歷下的最後一個結點放到p的位置。第二種是將p結點

Java資料結構：中根次序遍歷二叉排序樹

昨天離開了創新創業基地，有點難受，雖然換來了高效，但是總覺的難受，一起度過了半年，昨天離開了。說正事，今天更新二叉排序樹的中根遍歷。思想：其實沒啥，類似與二叉樹的非遞迴中

資料結構上機實驗-二叉排序樹的建立

#include<stdio.h> #include<string.h> #include<algorithm> using namespace std; typ

資料結構——二叉排序樹

建立、查詢、刪除

小甲魚老師的程式碼，我加了註釋：

完整程式碼code

相關推薦