2. 程式人生 > >二叉搜尋樹的基本操作 ---- 插入，刪除，查詢，銷燬，遍歷

二叉搜尋樹的基本操作 ---- 插入，刪除，查詢，銷燬，遍歷

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

首先來看看二叉搜尋樹的概念
二叉搜尋樹又稱二叉排序樹，它或者是一棵空樹，或者是具有以下性質的二叉樹

  • 若它的左子樹不為空，則左子樹上所有節點的值都小於根節點的值
  • 若它的右子樹不為空，則右子樹上所有節點的值都大於根節點的值
  • 它的左右子樹也分別為二叉搜尋樹

二叉搜尋樹的結構體

#define bool int
#define true 1
#define false 0
typedef int BDataType;
typedef struct BSTreeNode
{
    struct BSTreeNode* _pLeft;
    struct BSTreeNode* _pRight;
    BDataType _data;
}BSTNode;

初始化

void InitBSTree(BSTNode** pRoot)//初始化
{
    assert(pRoot);
    *pRoot = NULL;
}

插入
在二叉搜尋樹中插入新元素時，必須先檢測該元素是否在數中已經存在。如果已經存在，則不進行插入；否則將新元素加入到搜尋停止的地方。

BSTNode* BuyBSTreeNode(BDataType data)
{
    BSTNode* pNewNode = (BSTNode*)malloc(sizeof(BSTNode));
    if (pNewNode == NULL)
    {
        perror("malloc::BuyBSTreeNode"
 
);
        return NULL;
    }
    pNewNode->_data = data;
    pNewNode->_pLeft = NULL;
    pNewNode->_pRight = NULL;
    return pNewNode;
}
////非遞迴
bool InSertBSTree(BSTNode** pRoot, BDataType data)//插入
{
    BSTNode* parent = NULL;
    BSTNode* pNewNode = NULL;
    BSTNode* pCur = NULL;
    assert(pRoot);
    pCur =
 
 *pRoot;
    //空樹 ---- 直接插入
    if (*pRoot == NULL)
    {
        *pRoot = BuyBSTreeNode(data);
        return true;
    }
    //找該結點在二叉搜尋樹中的插入位置
    while (pCur)
    {
        parent = pCur;
        if (data < pCur->_data)
            pCur = pCur->_pLeft;
        else if (data > pCur->_data)
            pCur = pCur->_pRight;
        else
            return false;
    }

    ///插入結點
    pNewNode = BuyBSTreeNode(data);
    if (data < parent->_data)
        parent->_pLeft = pNewNode;
    else
        parent->_pRight = pNewNode;
    return true;
}
/////遞迴
bool InSertBSTree(BSTNode** pRoot, BDataType data)//插入
{
    assert(pRoot);
    if (*pRoot == NULL)
    {
        *pRoot = BuyBSTreeNode(data);
        return true;
    }
    else
    {
        if (data == (*pRoot)->_data)
            return false;
        else if (data < (*pRoot)->_data)
            return InSertBSTree(&(*pRoot)->_pLeft, data);
        else
            return InSertBSTree(&(*pRoot)->_pRight, data);
    }
}

查詢

/////////非遞迴
BSTNode* FindBSTree(BSTNode* pRoot, BDataType data)
{
    BSTNode* pCur = pRoot;
    while (pCur)
    {
        if (pCur->_data == data)
            return pCur;
        else if (data < pCur->_data)
            pCur = pCur->_pLeft;
        else
            pCur = pCur->_pRight;
    }
    return NULL;
}

/////遞迴
BSTNode* FindBSTree(BSTNode* pRoot, BDataType data)
{
    if (NULL == pRoot)
        return NULL;
    if (data == pRoot->_data)
        return pRoot;
    else if (data < pRoot->_data)
        return FindBSTree(pRoot->_pLeft, data);
    else
        return FindBSTree(pRoot->_pRight, data);
}

刪除
刪除比較複雜分為以下幾種情況
首先查詢元素是否在二叉搜尋樹中，如果不存在，則返回，否則要刪除的結點可能分以下四種情況：
1.要刪除的結點無孩子結點
2.要刪除的結點只有左孩子結點
3.要刪除的結點只有右孩子結點

情況1可以歸類到2或3
對於上述情況，相應的刪除方法如下：
1.直接刪除該結點
2.刪除該結點且使被刪除結點的雙親結點指向被刪除結點的左孩子結點
3.刪除該結點且使被刪除結點的雙親結點指向被刪除結點的右孩子結點
4.在它的左子樹中尋找中序下的第一個結點（關鍵碼最小），用它的值填補到被刪除結點中，再來處理該結點的刪除問題

///////非遞迴
bool DeleteBSTree(BSTNode** pRoot, BDataType data)//刪除
{
    BSTNode* pCur = NULL;
    BSTNode* parent = NULL;
    assert(pRoot);
    if (*pRoot == NULL)
        return;
    pCur = *pRoot;
    parent = pCur;
    while (pCur)
    {

        if (data == pCur->_data)
            break;
        else if (data < pCur->_data)
        {
            parent = pCur;          ///要指向pCur的上一個結點
            pCur = pCur->_pLeft;
        }
        else
        {
            parent = pCur;
            pCur = pCur->_pRight;
        }
    }
    ///該元素不在二叉樹中
    if (NULL == pCur)
        return false;

    ///在二叉搜尋樹中刪除pCur所指向的節點
    if (NULL == pCur->_pLeft)
    {
        //待刪除結點只有右孩子|| 葉子結點
        if (pCur == *pRoot)    //待刪除結點為根節點
            *pRoot = pCur->_pRight;
        ////pCur不為根結點
        else
        {
            if (parent->_pLeft == pCur)
                parent->_pLeft = pCur->_pRight;
            else
                parent->_pRight = pCur->_pRight;
        }

    }
    else if (NULL == pCur->_pRight)
    {
        ///待刪除節點只有左孩子
        if (pCur == *pRoot)
            *pRoot = pCur->_pLeft;
        else
        {
            if (parent->_pLeft == pCur)
                parent->_pLeft = pCur->_pLeft;
            else
                parent->_pRight = pCur->_pLeft;
        }
    }
    else
    {
        //待刪除節點左右孩子都存在
        BSTNode* pInOrder = pCur->_pRight;
        //找中序遍歷下的第一個結點（右子樹中最左側結點）
        while (pInOrder->_pLeft)
        {
            parent = pInOrder;
            pInOrder = pInOrder->_pLeft;
        }
        ///用該結點內容替換待刪除結點中資料
        pCur->_data = pInOrder->_data;

        ////刪除代替結點
        if (parent->_pLeft == pInOrder)
            parent->_pLeft = pInOrder->_pRight;
        else
            parent->_pRight = pInOrder->_pRight;
        pCur = pInOrder;
    }
    free(pCur);
    pCur = NULL;
    return true;
}


///////遞迴

bool DeleteBSTree(BSTNode** pRoot, BDataType data)//刪除
{
    assert(pRoot);
    if (*pRoot == NULL)
        return false;
    if (data < (*pRoot)->_data)
        return DeleteBSTree(&(*pRoot)->_pLeft, data);
    else if (data > (*pRoot)->_data)
        return DeleteBSTree(&(*pRoot)->_pRight, data);
    else
    {
        BSTNode* pDelNode = *pRoot;
        if (NULL == pDelNode->_pLeft)
        {
            *pRoot = pDelNode->_pRight;
            free(pDelNode);
            pDelNode = NULL;
            return true;
        }
        else if (NULL == pDelNode->_pRight)
        {
            *pRoot = pDelNode->_pLeft;
            free(pDelNode);
            pDelNode = NULL;
            return true;
        }
        else
        {
            BSTNode* pInOrder = pDelNode->_pRight;
            while (pInOrder->_pLeft)
                pInOrder = pInOrder->_pLeft;
            pDelNode->_data = pInOrder->_data; //將要刪除的結點替換
            return DeleteBSTree(&(*pRoot)->_pRight, pInOrder->_data);//去要刪除結點的右子樹中找替換後要刪除的結點，並刪除
        }
    }
}

銷燬

void DestroyBSTree(BSTNode** pRoot)//銷燬
{
    assert(pRoot);
    if (*pRoot)
    {
        DestroyBSTree(&(*pRoot)->_pLeft);
        DestroyBSTree(&(*pRoot)->_pRight);
        free(*pRoot);
        *pRoot = NULL;
    }
}

中序遍歷

void InOrder(BSTNode* pRoot)//中序遍歷
{
    if (pRoot)
    {
        InOrder(pRoot->_pLeft);
        printf("%d   ", pRoot->_data);
        InOrder(pRoot->_pRight);
    }
}

相關推薦

C語言-二叉樹基本操作以及二叉搜尋樹基本操作

功能 二叉樹操作: 建立二叉樹 遍歷二叉樹(前序,中序,後續) 計算高度 計算結點數目 清空二叉樹 空樹判斷 二叉搜尋樹操作: 插入 最值(最大值,最小值) 刪除 程式碼 #include &l

二叉搜尋樹建立、插入、刪除、前繼節點、後繼節點之c++實現

#include "stdafx.h" #include <string> #include <stdlib.h> #include <iostream> using namespace std; typedef struct Node { int key;

Insert into a Binary Search Tree 二叉搜尋樹中的插入操作

給定二叉搜尋樹（BST）的根節點和要插入樹中的值，將值插入二叉搜尋樹。 返回插入後二叉搜尋樹的根節點。 保證原始二叉搜尋樹中不存在新值。 注意，可能存在多種有效的插入方式，只要樹在插入後仍保持為二叉搜尋樹即可。 你可以返回任意有效的結果。 例如,  給定二叉搜尋樹:

二叉搜尋樹的根插入、選擇、刪除、合併、排序等操作的實現

原始碼如下： 這裡的Key 不當為關鍵字對待， 而是把Item.c作為關鍵字對待 #include <stdlib.h> #include <stdio.h> //#define Key int typedef int Key; struct I

二叉搜尋樹的節點插入，查詢。

在講解二分搜尋樹之前，我想先講清楚一個東西，那就是遞迴，因為在後面的插入，查詢操作都是利用遞迴去查詢的，而且對於遞迴的理解也是一個難點，因此，以下是我對於遞迴的理解。，對於遞迴，我們不能用人腦去展開來想

[PTA] 資料結構與演算法題目集 6-12 二叉搜尋樹的操作集

唯一比較需要思考的刪除操作： 被刪除節點有三種情況： 1、葉節點，直接刪除 2、只有一個子節點，將子節點替換為該節點，刪除該節點。 3、有兩個子節點，從右分支中找到最小節點，將其值賦給被刪除節點的位置，接著刪除這個最小節點   　// 函式Insert將X插入二叉搜尋樹BST並返

04-樹7 二叉搜尋樹的操作集 （30 分）

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

6-12 二叉搜尋樹的操作集-PTA

函式介面定義： BinTree Insert( BinTree BST, ElementType X ); BinTree Delete( BinTree BST, ElementType X ); Position Find( BinTree BST, ElementType X ); P

樹7 二叉搜尋樹的操作集

函式介面定義： BinTree Insert( BinTree BST, ElementType X ); BinTree Delete( BinTree BST, ElementType X ); Position Find( BinTree BST, ElementTy

《資料結構》04-樹7 二叉搜尋樹的操作集

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

PTA資料結構與演算法題目集（中文）4-12 二叉搜尋樹的操作集 (30分)

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

資料結構---04-樹7 二叉搜尋樹的操作集（30 分）

#include<cstdio> #include<cstdlib> #include<iostream> using namespace std; typedef int ElementType; typedef struct TNode* Position; typed

資料結構——樹（7）——二叉搜尋樹及其操作原理

二叉樹與二叉搜尋樹 在之前的文章中，我們提到過三叉樹，n叉樹，但是我們實際用的最多卻是二叉樹，因為這樣的結構更適合我們程式設計和更適合我們使用遞迴的方式。所以我們可以限制孩子的數量使得生成的樹更容易實施。那麼怎麼定義二叉樹呢？ - 樹中的每個節點至多有兩個孩

C語言二叉排序樹基本操作

定義： 二叉排序樹是一棵特殊的二叉樹。其必須滿足：要麼為空樹或者樹上任一結點，其值大於等於其左子樹上的任意結點值（左子樹非空），且小於其右子樹上任意結點的值（右子樹非空），其左右子樹也滿足該定義。 結

二叉搜尋樹的操作題集

BinTree Insert( BinTree BST, ElementType X ) { if(BST==NULL) { BinTree gg=(BinTree)malloc(sizeof(struct TNode)); gg->Data=X; gg->Left=NULL;

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

#include <stdio.h> #include <stdlib.h> typedef int ElementType; typedef struct TNode *Position; typedef Position Bin

04-樹7 二叉搜尋樹的操作集

二叉搜尋樹的各種操作！ 程式碼： #include <stdio.h> #include <stdlib.h> typedef int ElementType; typedef struct TNode *Position; typedef P

4-12 二叉搜尋樹的操作集 (30分)

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

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

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

二叉排序樹的建立、插入、刪除、查詢、4種遍歷 C++完整實現

#include<iostream> #include<string> #include<queue> using namespace std; typedef int KeyType; #define NUM 13 class Bi