2. 程式人生 > >STL原始碼筆記（17）—二叉排序樹BST（C++封裝）

STL原始碼筆記（17）—二叉排序樹BST（C++封裝）

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

二叉排序樹BST

STL中還有一類非常重要的容器，就是關聯容器，比如map啊set啊等等，這些容器說實話，在應用層上還不能完全得心應手（比如幾種容器效率的考慮等等），更別說原始碼了，因此這一部分打算穩紮穩打，好好做做筆記研究一番。
說到關聯容器，我們想到了什麼AVL樹，紅黑樹等等，但大多時候我們僅僅侷限於知道其名字，或者知道其概念，俗話說“talk is cheap，show me the code”，因此，我打算從他們的祖爺爺二叉排序樹開始下手。（其實，侯老師的書上也是這麼安排的哈）

1.概念

1.任意節點的左子樹不空，則左子樹上所有節點的值均小於它的根節點的值；
2.任意節點的右子樹不空，則右子樹上所有節點的值均大於它的根節點的值；
3.任意節點的左、右子樹也分別為二叉查詢樹；
4.沒有鍵值相等的節點。
二叉查詢樹相比於其他資料結構的優勢在於查詢、插入的時間複雜度較低。為O

(logn)。二叉查詢樹是基礎性資料結構，用於構建更為抽象的資料結構，如集合、multiset、關聯陣列等。

2.性質

1.中序遍歷是一個升序的有序序列。
2.搜尋、插入、刪除的複雜度等於樹高，期望O(logn)，最壞O(n)（數列有序，樹退化成線性表）。

3.二叉排序樹的實現

既然看到此，不如試著實現一下二叉排序樹，主要需要包含這些操作：構建二叉排序樹輸入一個序列輸出一個二叉排序樹，插入、刪除節點。

寫程式碼之前考慮的問題：

1.二叉排序樹的插入一定是在葉子節點處。

2.二叉排序樹的刪除需要考慮三種情況：
　　a）待刪除節點在葉子節點處
　　　　直接另其父節點相應指標制空，並刪除該節點即可。
　　b）待刪除節點只含有一個孩子（左子樹為空或者右子樹為空）


　　　　將待刪除節點父節點對應指標指向待刪除節點的孩子節點。
　　c）待刪除節點即包含左右孩子都不為空
　　　　找到待刪除節點的右子樹的最小值（右子樹一路向左），並將該值替換待刪除節點的值，最後刪除最小值原本所在位置的節點（葉子節點）。

3.二叉排序樹的中序遍歷是升序。
4.擯棄以前的C語言寫法，我這次想把BST封裝成一個C++類，雖然困難重重，勉強實現了吧。
5.既然是C++類，在解構函式中做所有節點記憶體釋放處理（最後一個根節點需要特殊處理）。

上述5個問題中除了對C++的熟悉程度外，涉及BST演算法部分最麻煩的就是刪除操作了，因為它考慮的情況比較多，這裡貼出侯老師書中的示意圖方便理解：

目標節點只有一個孩子節點

這裡寫圖片描述

目標節點有兩個子節點

這裡寫圖片描述

程式碼

編譯執行環境：Visual Studio 2013，Windows 7 32 bits

（1）二叉排序樹的節點資料結構

//BSTNode.h
#ifndef __BSTNODE_H__
#define __BSTNODE_H__
#include<iostream>
class BSTNode{
public:
    BSTNode();
    BSTNode(int val);
    int value;
    BSTNode *lchild;
    BSTNode *rchild;
};
#endif

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

//BSTNode.cpp
#include "BSTNode.h"
BSTNode::BSTNode()
{
    value = 0;
    lchild = NULL;
    rchild = NULL;
}
BSTNode::BSTNode(int val)
{
    value = val;
    lchild = NULL;
    rchild = NULL;
}

（2）二叉排序樹的C++類封裝

//BST.h
#ifndef __BST_H__
#define __BST_H__
#include "BSTNode.h"
#include <vector>
#include <iostream>
class BSTNode;
class BST
{
    //說明：
    //為了資料結構私有化，不為外部訪問，這裡提供一些私有內部函式實現真正的操作以"__"開頭。
    //對於public的介面來說，只需要直接呼叫內部函式即可
private:
    BSTNode * bstroot;//二叉排序樹資料結構
    BSTNode * __search(BSTNode* root,const int& key);//查詢關鍵字
    BSTNode * __treeMin(BSTNode*const root,BSTNode *&parent);//返回當前節點的最小孩子（一路向左）
    BSTNode * __treeMax(BSTNode*const root);//查詢最大值（未實現）
    bool __Insert( const int &key);//插入節點
    bool __Delete(const int &key);//刪除刪除
    bool __isLeaf(BSTNode* const &);//判斷是否是葉子節點
    bool __isNodeWithTwoChild(BSTNode * const &);//判斷是否有兩個孩子
    void __InorderTraversal(BSTNode *root,std::vector<int>&result);//中序遍歷
    void __DeleteAllNodes(BSTNode *root);//刪除所有節點
public:
    //建構函式
    BST();//預設建構函式
    BST(std::vector<int>arr);
    BST(int *arr, int len);
    //解構函式
    ~BST();
    bool isEmpty() const;//判斷樹空
    bool search(const int &key);//查詢關鍵字是否存在的對外介面
    bool Insert(const int &key);//插入節點的外部介面
    bool Delete(const int &key);//刪除節點的外部介面
    void InorderTraversal(std::vector<int>&);//中序遍歷的外部介面
};
#endif

（3）二叉排序樹C++類實現部分

//BST.cpp

#include "BST.h"

//判斷樹空
bool BST::isEmpty() const
{
    return bstroot == NULL;
}

//判斷是否是葉子節點（刪除部分用到）
bool BST::__isLeaf(BSTNode*const & root)
{
    if ((root->lchild == NULL) && (root->rchild == NULL))
        return true;
    else
        return false;
}

//判斷節點是否有兩個孩子（刪除部分用到）
bool BST::__isNodeWithTwoChild(BSTNode * const & root)
{
    if (root->lchild != NULL &&root->rchild != NULL)
        return true;
    else
        return false;
}

//找到當前節點為根的子樹中的最小值（刪除部分用到，因此返回其父節點和當前節點）
BSTNode * BST::__treeMin(BSTNode*const root,BSTNode *&parent)
{
    BSTNode * curr = root;
    while (curr->lchild != NULL)
    {
        parent = curr;
        curr = curr->lchild;
    }
    return curr;
}

//刪除節點內部實現
bool BST::__Delete(const int &key)
{
    bool found = false;//找到待刪除的元素
    if (isEmpty())
    {
        std::cerr << "Binary Search Tree Is Empty" << std::endl;//BST為空
        return false;
    }
    BSTNode * curr = bstroot;
    BSTNode *parent = NULL;
    while (curr != NULL)//查詢待刪除節點
    {

        if (key == curr->value)
        {
            found = true;
            break;
        }
        else 
        {
            parent = curr;
            if (key < curr->value)
                curr = curr->lchild;
            else
                curr = curr->rchild;
        }
    }
    if (!found)
    {
        std::cerr << "KeyValue Not Found" << std::endl;
        return false;
    }
    if (NULL == parent)//刪除最後一個節點(根節點需要特殊處理)
    {
        bstroot = NULL;
        delete curr;
        return true;
    }
    //對於待刪除的節點有三種可能：
    //1.葉子節點
    //2.只包含左子樹或者右子樹（單個孩子）
    //3.既包含左子樹又包含右子樹
    //刪除節點的時候需要分3種情況進行考慮

    if (__isLeaf(curr))//葉子節點
    {
        if (parent->lchild == curr)
            parent->lchild = NULL;
        else
            parent->rchild = NULL;
        delete curr;
        return true;
    }//end if
    else if (__isNodeWithTwoChild(curr))//有兩個孩子的節點
    {
        //以當前節點的右子樹中的最小值取代它
        BSTNode*parent=curr;
        BSTNode *tmp = __treeMin(curr->rchild,parent);
        curr->value = tmp->value;
        if (parent->rchild == tmp)
            parent->rchild = NULL;
        else
            parent->lchild = NULL;
        delete tmp;
        return true;
    }//end else-if
    else//只有一個孩子的節點
    {
        if (curr->lchild != NULL)//只有左孩子
        {
            if (parent->lchild == curr)
            {
                parent->lchild = curr->lchild;
                delete curr;
                return true;
            }
            else
            {
                parent->rchild = curr->lchild;
                delete  curr;
                return true;
            }
        }
        if (curr->rchild != NULL)//只有右孩子
        {
            if (parent->lchild == curr)
            {
                parent->lchild = curr->rchild;
                delete curr;
                return true;
            }
            else
            {
                parent->rchild = curr->rchild;
                delete  curr;
                return true;
            }
        }
    }//end else
    return false;
}
//刪除操作的外部介面
bool BST::Delete(const int &key)
{
    return __Delete(key);
}

//插入節點的內部實現，插入操作一定都在葉子節點處。
bool BST::__Insert(const int & key)
{
    BSTNode* t = new BSTNode(key);//臨時節點
    BSTNode*parent = NULL;
    if (isEmpty())//新樹
    {
        bstroot = t;
        return true;
    }
    else
    {
        BSTNode* curr;
        curr = bstroot;
        while (curr)
        {
            //插入位置都位於葉子節點處
            parent = curr;
            if (t->value > curr->value)
                curr = curr->rchild;
            else
                curr = curr->lchild;
        }
        if (t->value < parent->value)
        {
            parent->lchild = t;
            return true;
        }
        else
        {
            parent->rchild = t;
            return true;
        }
    }
    return false;
}
//插入節點的外部介面
bool BST::Insert(const int &key)
{
    return __Insert(key);
}

//建構函式
BST::BST()//預設建構函式
{
    bstroot = NULL;
}
BST::BST(int*arr, int len)//陣列構造
{
    bstroot = NULL;
    for (int i = 0; i < len; i++)
    {
        __Insert(*(arr + i));
    }
}

BST::BST(std::vector<int>arr)//容器構造
{
    bstroot = NULL;
    for (int i = 0; i < (int)arr.size(); i++)
    {
        __Insert(arr[i]);
    }
}

//內部查詢函式
//遞迴呼叫
BSTNode* BST::__search(BSTNode*root,const int& key)
{
    if (NULL == root)
        return NULL;
    if (key == root->value)
        return root;
    else if (key < root->value)
        return __search(root->lchild, key);
    else
        return __search(root->rchild, key);
}
//查詢函式介面
bool BST::search(const int& key)
{
    BSTNode*t = __search(bstroot, key);
    return t == NULL ? false : true; 
}

//中序遍歷內部實現
void BST::__InorderTraversal(BSTNode *root,std::vector<int>&result)
{
    if (NULL == root)
        return;
    __InorderTraversal(root->lchild, result);
    std::cout << root->value << " ";
    result.push_back(root->value);
    __InorderTraversal(root->rchild, result);
}
//中序遍歷介面，vector儲存遍歷結果
void BST::InorderTraversal(std::vector<int>&result)
{
    __InorderTraversal(bstroot, result);
}

//刪除所有節點（析構用）
void BST::__DeleteAllNodes(BSTNode *root)
{
    if (root == NULL)
    {
        return;
    }
    __DeleteAllNodes(root->lchild);
    __DeleteAllNodes(root->rchild);
    __Delete(root->value);
}

//解構函式
BST::~BST()
{
    BSTNode*curr = bstroot;
    __DeleteAllNodes(curr);
}

（4）二叉排序樹的測試程式碼

//main.cpp
#include "BST.h"
int main()
{
    std::vector<int>vec = { 8,6,2,5,1,3,7 };
    BST bst(vec);
    bst.Delete(9);//Not found

    bst.Insert(4);
    bool found=bst.search(4);
    if (!found)
        std::cout << "not found" << std::endl;
    else
        std::cout << "found!" << std::endl;
    std::vector<int>result;
    bst.InorderTraversal(result);
    std::cout << std::endl;
    for (int i = 0; i < result.size(); i++)
    {
        std::cout << result[i] << " ";
    }
    std::cout << std::endl;
    system("pause");
    return 0;
}

4.參考

相關推薦

STL原始碼筆記（17）—二叉排序樹BST（C++封裝）

二叉排序樹BST STL中還有一類非常重要的容器，就是關聯容器，比如map啊set啊等等，這些容器說實話，在應用層上還不能完全得心應手（比如幾種容器效率的考慮等等），更別說原始碼了，因此這一部分打算穩紮穩打，好好做做筆記研究一番。 說到關聯容器，我們想到了什

二叉排序樹BST（未完、佔坑）

#include <stdio.h> #include <stdlib.h> typedef struct BSTNode{ int data; struct BSTNode *lchild,*rchild; }BSTNode,*BSTree; int

基礎資料結構與演算法實現（2）—二叉搜尋樹BST

import java.util.LinkedList; import java.util.Queue; public class BST <E extends Comparable<E>> { private c

《 常見演算法與資料結構》符號表ST（4）——二叉查詢樹刪除 （附動畫）

符號表ST（4）——二叉查詢樹刪除 （附動畫） 本系列文章主要介紹常用的演算法和資料結構的知識，記錄的是《Algorithms I/II》課程的內容，採用的是“演算法（第4版）”這本紅寶書作為

輕鬆解決不同關鍵字序列構成的二叉排序樹ASL（平均查詢長度）（成功）不同問題

打算就說說標題的方法，和介紹一下查詢成功和非成功二叉樹中結點的方法 關鍵字序列1,2,3,4,5構造而得的二叉排序樹 ASL=（1,2,3,4,5）/5=3 按關鍵字3,1,2,5,4構造而得的二叉排序樹 ASL=(1+2+

資料結構與演算法（C語言） | 二叉排序樹

二叉排序樹的定義—— 二叉排序樹 ( Binary Sort Tree) 或者為空；或者是具有如下特性的二叉樹： （1）若根的左子樹不空，則左子樹上所有結點的關鍵字均小於根結點的關鍵字； （2）若

構造二叉排序樹（BST）+二叉排序樹的刪除

主要是刪除操作 二叉排序樹的刪除 1. 刪除葉結點，直接刪除 2. 刪除結點p只有左子樹或右子樹，讓其子樹替代該結點p即可 3. 刪除結點p既有左子樹又有右子樹，以該結點p為根，查詢中序遍歷下第一個結點t，使這個結點t替換p結點（val覆蓋即可），再遞迴一次刪除這個結點t即

查詢（3）——二叉排序樹的建立、結點的查詢和刪除

#include <stdio.h> #include <stdlib.h> typedef struct node{ int data; node * lchild; node * rchild; }BTree

二叉排序樹實現（C語言）

#include <stdio.h> #include <stdlib.h> // 定義基本的資料結構和型別預定義 struct TreeNode; typedef struct TreeNode *Position; typedef

九度筆記之 1467：二叉排序樹

題目1467：二叉排序樹 時間限制：1 秒 記憶體限制：128 兆 特殊判題：否 提交：1292 解決：518 題目描述：         二叉排序樹，也稱為二叉查詢樹。可以是一顆空樹，也可以是一顆具有如下特性的非空二叉樹：         1

二叉搜尋樹(二叉排序樹)BST與雙向列表的轉換

目錄 1.二叉排序樹（Binary Sort Tree) 二叉排序樹又稱二叉查詢樹(Binary Search Tree) BST 二叉排序樹或者是一顆空樹，或者是滿足一下性質的一顆二叉樹： 若它的左子樹非空，則左子樹上

二叉排序樹(BST)的思路及C語言實現

請注意，為了能夠更好的理解二叉排序樹，我建議各位在看程式碼時能夠設定好斷點一步一步跟蹤函式的執行過程以及各個變數的變化情況 一.動態查詢所面臨的問題 在進行動態查詢操作時，如果我們是在一個無序的線性表中進行查詢，在插入時可以將其插入表尾，表長加1即可；刪除時

二叉排序樹(BST)的判定(其實不容易)

      對於BST，一定要理解透徹，下面，我們給出一個有錯誤的BST判定程式： // 程式中的isBST函式的邏輯是有錯誤 #include <iostream> #define N 7 using namespace std; // BST的結點 t

第九章查詢表-二叉排序樹-計算機17級（帶詳細解析）

解析在後面：       解析： x2-1：   要注意這個二叉搜尋樹還是個完全二叉樹，只有二叉樹時最大值才一定在葉結點上，且中位值一定要注意，肯定是在根結點或根的左子樹上 x2-2：之前就做過，畫出圖就好了 x2

劍指offer學習筆記（Python）--二叉搜尋樹的後序遍歷序列

題目描述 輸入一個整數陣列，判斷該陣列是不是某二叉搜尋樹的後序遍歷的結果。如果是則輸出Yes,否則輸出No。假設輸入的陣列的任意兩個數字都互不相同。 思路 知識點回顧： 二叉搜尋樹（Binary Search Tree，BST)又稱二叉排序樹、二叉查詢樹  

Linux學習筆記（演算法與資料結構）之 二叉搜尋樹程式碼（C語言）

1、程式碼在VS2010的C++編譯器中編譯通過，可能有極少部分語法不符合C99標準；bool型別無法使用，用int代替 2、由於VS配置問題，沒有分.c和.h檔案書寫；如果要分，最好將Create_Node和Destory_Node加上static關鍵字修飾，他們只會在所

二叉查詢樹（二叉排序樹）學習筆記

本文轉載自：http://blog.csdn.net/qq_37887537/article/details/75647670在學習資料結構的時候，除了基本的之外的，還有許多樹像是二叉搜尋樹，2-3樹，紅黑樹等等。也曾經學習過二叉樹，以及前序排列中序排列後序排列等等，但是一直

BST（二叉排序樹）的插入與刪除

最小值 temp def oot gpo 一個 記錄 通過 如果 值得一說的是刪除操作，刪除操作我們分為三種情況： 1.要刪的節點有兩個孩子： 　　找到左子樹中的最大值或者右子樹中的最小值所對應的節點，記為node，並把node的值賦給要刪除的節點del,然後刪除node

【Java】 大話數據結構(11) 查找算法(2)（二叉排序樹/二叉搜索樹）

PE bsp clas 代碼 根節點 替代 找到 extend true 本文根據《大話數據結構》一書，實現了Java版的二叉排序樹/二叉搜索樹。 二叉排序樹介紹 在上篇博客中，順序表的插入和刪除效率還可以，但查找效率很低；而有序線性表中，可以使用折半、插值、斐波

創建二叉樹（ 二叉排序樹（Binary Sort Tree））

sort data scanf urn pre [] print 二叉樹 str #include<stdio.h> #include<stdlib.h> /* 遞歸前中後遍歷 */ typedef struct node { int data;