二叉搜尋樹的初始化、插入、刪除、查詢、銷燬等操作

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

二叉搜尋樹的概念

二叉搜尋樹又稱二叉排序樹，它或者是一顆空樹，或者是具有以下性質的二叉樹：

若它的左子樹不為空，則左子樹上所有結點的值都小於根結點的值
若它的右子樹不為空，則右子樹上所有結點的值都大於根結點的值
它的左右子樹也分別為二叉搜尋樹例：我們要實現這些操作。先定義一個二叉搜尋樹的結構體，這個結構體成員包括左右孩子兩個指標，還有它的資料：

typedef int BSDataType;
typedef struct BSTreeNode
{
    struct BSTreeNode* _pLeft;
    struct BSTreeNode* _pRight;
    BSDataType _data;
}BSTNode;

二叉搜尋樹的初始化：需要傳入二級指標，因為要改變根結點的指向，讓根結點指向空

void InitBSTree(BSTNode** pRoot)
{
    assert(pRoot);
    *pRoot = NULL;
}

二叉搜尋樹的插入：分析：

樹為空，則直接插入（這也是傳二級指標的原因，因為要改變根結點的指向） 2.樹不空，按二叉搜尋樹性質查詢插入位置，插入新結點

非遞迴程式碼：

bool InsertBSTree(BSTNode** pRoot, BSDataType data)
{
    assert(pRoot);
    if (*pRoot == 
 NULL)
    {
        (*pRoot) = BuyBSTNode(data);
        return true;
    }
    else
    {
        BSTNode* pCur = (*pRoot);
        BSTNode *pParent = NULL;
        //找到插入結點的位置
        while (pCur)
        {
            pParent = pCur;
            if (pCur->_data == data)//如果當前結點=要插入的結點，則退出，因為這個元素已經存在 

            {
                return false;
            }
            else if (pCur->_data > data)//如果當前結點數>要插入的數，向當前結點的左子樹去找插入位置
            {
                pCur = pCur->_pLeft;
            }
            else//如果當前結點數<要插入的數，向當前結點的右子樹去找插入位置
            {
                pCur = pCur->_pRight;
            }
        }
        //插入新結點
        if (data > pParent->_data)//如果插入的元素比它要插入位置的元素大，則要插入的元素應該是要插入位置結點的右孩子
        {
            pParent->_pRight = BuyBSTNode(data);
            return true;
        }
        if (data < pParent->_data)//如果插入的元素比它要插入位置的元素小，則要插入的元素應該是要插入位置結點的左孩子
        {
            pParent->_pLeft = BuyBSTNode(data);
            return true;
        }
    }
    return false;
}

遞迴程式碼：

bool InsertBSTreeNor(BSTNode** pRoot, BSDataType data)
{
    assert(pRoot);
    if (NULL == *pRoot)
        *pRoot = BuyBSTNode(data);
    else
    {
        if (data == (*pRoot)->_data)
        {
            return false;
        }
        else if (data < (*pRoot)->_data)
            return InsertBSTree(&(*pRoot)->_pLeft, data);
        else
            return InsertBSTree(&(*pRoot)->_pRight, data);

    }
    return true;
}

二叉搜尋樹的刪除：分析：刪除的話就有點複雜了，因為刪除結點的位置不同，我們處理的方式不同。首先查詢元素是否在二叉搜尋樹中，如果不存在，則返回，否則要刪除的結點可能分下面四種情況： 1.要刪除的結點無孩子結點 2.要刪除的結點只有左孩子結點 3.要刪除的結點只有右孩子 4.要刪除的結點有左、有結點這裡寫圖片描述非遞迴程式碼：

bool DelectBSTree(BSTNode** pRoot, BSDataType data)
{
    assert(pRoot);
    BSTNode* pCur = NULL;
    BSTNode* pParent = NULL;
    if (NULL == *pRoot)
        return false;
    else
    {
        //找到待刪除結點

        pCur = *pRoot;
        while (pCur)
        {
            if (data > pCur->_data)
            {
                pParent = pCur;
                pCur = pCur->_pRight;
            }
            else if (data < pCur->_data)
            {
                pParent = pCur;
                pCur = pCur->_pLeft;
            }
            else
                break;
        }
        //刪除結點

        //待刪結點是葉子節點或者只有右孩子
        if (NULL == pCur->_pLeft)
        {
            if (pCur == *pRoot)//若果刪除的是根結點
                *pRoot = pCur->_pRight;
            else if (pCur == pParent->_pLeft)
                pParent->_pLeft = pCur->_pRight;
            else
                pParent->_pRight = pCur->_pRight;
        }
        //只有左孩子
        else if (NULL == pCur->_pRight)
        {
            if (pCur == *pRoot)//若果刪除的是根結點
                *pRoot = pCur->_pLeft;
            else if (pCur == pParent->_pLeft)
                pParent->_pLeft = pCur->_pLeft;
            else
                pParent->_pRight = pCur->_pLeft;
        }
        //左右孩子都存在
        else
        {
            //替代法，向待刪除點的右子樹找最左邊的數（最小）/向待刪除點的左子樹找最右邊的數（最大），將待刪除點與最左邊/最右邊的數交換，刪除最左邊/最右邊的數
            BSTNode* Inorder = pCur->_pRight;

            while (Inorder->_pLeft)//除了迴圈函式，Inorder不可能有左孩子
            {
                pParent = Inorder;
                Inorder = Inorder->_pLeft;
            }
            pCur->_data = Inorder->_data;//交換
            if (Inorder == pParent->_pLeft)
                pParent->_pLeft = Inorder->_pRight;
            else if (Inorder == pParent->_pRight)
                pParent->_pRight = Inorder->_pRight;
            pCur = Inorder;
        }
    }
    free(pCur);
    pCur = NULL;
    return true;
}

遞迴程式碼：

bool DelectBSTreeNor(BSTNode** pRoot, BSDataType data)
{
    assert(pRoot);

    if (NULL == *pRoot)
        return false;
    else
    {

        if (data > (*pRoot)->_data)
        {
            return DelectBSTreeNor(&(*pRoot)->_pRight, data);
        }
        else if (data < (*pRoot)->_data)
        {
            return DelectBSTreeNor(&(*pRoot)->_pLeft, data);
        }
        else //data == (*pRoot)->_data
        {
            //這時已經找到了待刪除結點
            BSTNode* pDel = *pRoot;
            if (NULL == pDel->_pLeft)
            {
                *pRoot = pDel->_pRight;
                free(pDel);
                return true;
            }
            else if (NULL == (*pRoot)->_pRight)
            {
                *pRoot = pDel->_pLeft;
                free(pDel);
                return true;
            }
            else //左右孩子都存在
            {
                BSTNode* Inorder = pDel->_pRight;
                while (Inorder->_pLeft)
                    Inorder = Inorder->_pLeft;
                pDel->_data = Inorder->_data;
                return DelectBSTreeNor(&(*pRoot)->_pRight, pDel->_data);
            }
        }
    }
}

二叉搜尋樹的查詢：我們根據二叉搜尋樹的性質可以得出，如果要找的資料比當前根結點的資料小，我們應該往當前根結點的左子樹去找，如果比當前根結點的資料大，往當前根結點的右子樹去找。

非遞迴程式碼：

BSTNode* FindBSTree(BSTNode* pRoot, BSDataType data)
{
    BSTNode* pCur = NULL;
    if (NULL == pRoot)
        return NULL;

    pCur = pRoot;
    while (pCur)
    {
        if (pCur->_data == data)
        {
            return pCur;
        }
        else if (pCur->_data > data)
        {
            pCur = pCur->_pLeft;
        }
        else
        {
            pCur = pCur->_pRight;
        }
    }
    return NULL;
}

遞迴程式碼：


BSTNode* FindBSTreeNor(BSTNode* pRoot, BSDataType data)
{
    if (NULL == pRoot)
        return NULL;
    else if (data == pRoot->_data)
        return pRoot;
    else if (data < pRoot->_data)
        return FindBSTreeNor(pRoot->_pLeft, data);
    else
        return FindBSTreeNor(pRoot->_pRight, data);

}

下面是完整的程式碼： BSTree.h

#ifndef __BSTREE_H__
#define __BSTREE_H__

#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#define bool int
#define true 1
#define false 0

typedef int BSDataType;
typedef struct BSTreeNode
{
    struct BSTreeNode* _pLeft;
    struct BSTreeNode* _pRight;
    BSDataType _data;
}BSTNode;

void InitBSTree(BSTNode** pRoot);
bool InsertBSTree(BSTNode** pRoot, BSDataType data);
bool InsertBSTreeNor(BSTNode** pRoot, BSDataType data);
bool DelectBSTree(BSTNode** pRoot, BSDataType data);
bool DelectBSTreeNor(BSTNode** pRoot, BSDataType data);
BSTNode* FindBSTree(BSTNode* pRoot, BSDataType data);
BSTNode* FindBSTreeNor(BSTNode* pRoot, BSDataType data);
void DestroyBSTree(BSTNode** pRoot);

#endif //__BSTREE_H__

BSTree.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"BSTree.h"

void InitBSTree(BSTNode** pRoot)
{
    assert(pRoot);
    *pRoot = NULL;
}

BSTNode* BuyBSTNode(BSDataType data)
{
    BSTNode* newNode = (BSTNode*)malloc(sizeof(BSTNode));
    if (NULL == newNode)
    {
        printf("建立節點失敗\n");
        return NULL;
    }
    newNode->_data = data;
    newNode->_pLeft = NULL;
    newNode->_pRight = NULL;
    return newNode;
}

void InOrder(BSTNode* pRoot)
{
    if (NULL == pRoot)
        return;
    InOrder(pRoot->_pLeft);
    printf("%d ", pRoot->_data);
    InOrder(pRoot->_pRight);
}

bool InsertBSTree(BSTNode** pRoot, BSDataType data)
{
    assert(pRoot);
    if (*pRoot == NULL)
    {
        (*pRoot) = BuyBSTNode(data);
        return true;
    }
    else
    {
        BSTNode* pCur = (*pRoot);
        BSTNode *pParent = NULL;
        //找到插入結點的位置
        while (pCur)
        {
            pParent = pCur;
            if (pCur->_data == data)//如果當前結點=要插入的結點，則退出，因為這個元素已經存在
            {
                return false;
            }
            else if (pCur->_data > data)//如果當前結點數>要插入的數，向當前結點的左子樹去找插入位置
            {
                pCur = pCur->_pLeft;
            }
            else//如果當前結點數<要插入的數，向當前結點的右子樹去找插入位置
            {
                pCur = pCur->_pRight;
            }
        }
        //插入新結點
        if (data > pParent->_data)//如果插入的元素比它要插入位置的元素大，則要插入的元素應該是要插入位置結點的右孩子
        {
            pParent->_pRight = BuyBSTNode(data);
            return true;
        }
        if (data < pParent->_data)//如果插入的元素比它要插入位置的元素小，則要插入的元素應該是要插入位置結點的左孩子
        {
            pParent->_pLeft = BuyBSTNode(data);
            return true;
        }
    }
    return false;
}

bool DelectBSTree(BSTNode** pRoot, BSDataType data)
{
    assert(pRoot);
    BSTNode* pCur = NULL;
    BSTNode* pParent = NULL;
    if (NULL == *pRoot)
        return false;
    else
    {
        //找到待刪除結點

        pCur = *pRoot;
        while (pCur)
        {
            if (data > pCur->_data)
            {
                pParent = pCur;
                pCur = pCur->_pRight;
            }
            else if (data < pCur->_data)
            {
                pParent = pCur;
                pCur = pCur->_pLeft;
            }
            else
                break;
        }
        //刪除結點

        //待刪結點是葉子節點或者只有右孩子
        if (NULL == pCur->_pLeft)
        {
            if (pCur == *pRoot)//若果刪除的是根結點
                *pRoot = pCur->_pRight;
            else if (pCur == pParent->_pLeft)
                pParent->_pLeft = pCur->_pRight;
            else
                pParent->_pRight = pCur->_pRight;
        }
        //只有左孩子
        else if (NULL == pCur->_pRight)
        {
            if (pCur == *pRoot)//若果刪除的是根結點
                *pRoot = pCur->_pLeft;
            else if (pCur == pParent->_pLeft)
                pParent->_pLeft = pCur->_pLeft;
            else
                pParent->_pRight = pCur->_pLeft;
        }
        //左右孩子都存在
        else
        {
            //替代法，向待刪除點的右子樹找最左邊的數（最小）/向待刪除點的左子樹找最右邊的數（最大），將待刪除點與最左邊/最右邊的數交換，刪除最左邊/最右邊的數
            BSTNode* Inorder = pCur->_pRight;

            while (Inorder->_pLeft)//除了迴圈函式，Inorder不可能有左孩子
            {
                pParent = Inorder;
                Inorder = Inorder->_pLeft;
            }
            pCur->_data = Inorder->_data;//交換
            if (Inorder == pParent->_pLeft)
                pParent->_pLeft = Inorder->_pRight;
            else if (Inorder == pParent->_pRight)
                pParent->_pRight = Inorder->_pRight;
            pCur = Inorder;
        }
    }
    free(pCur);
    pCur = NULL;
    return true;
}

BSTNode* FindBSTree(BSTNode* pRoot, BSDataType data)
{
    BSTNode* pCur = NULL;
    if (NULL == pRoot)
        return NULL;

    pCur = pRoot;
    while (pCur)
    {
        if (pCur->_data == data)
        {
            return pCur;
        }
        else if (pCur->_data > data)
        {
            pCur = pCur->_pLeft;
        }
        else
        {
            pCur = pCur->_pRight;
        }
    }
    return NULL;
}

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

BSTNode* FindBSTreeNor(BSTNode* pRoot, BSDataType data)
{
    if (NULL == pRoot)
        return NULL;
    else if (data == pRoot->_data)
        return pRoot;
    else if (data < pRoot->_data)
        return FindBSTreeNor(pRoot->_pLeft, data);
    else
        return FindBSTreeNor(pRoot->_pRight, data);

}

bool InsertBSTreeNor(BSTNode** pRoot, BSDataType data)
{
    assert(pRoot);
    if (NULL == *pRoot)
        *pRoot = BuyBSTNode(data);
    else
    {
        if (data == (*pRoot)->_data)
        {
            return false;
        }
        else if (data < (*pRoot)->_data)
            return InsertBSTree(&(*pRoot)->_pLeft, data);
        else
            return InsertBSTree(&(*pRoot)->_pRight, data);

    }
    return true;
}

bool DelectBSTreeNor(BSTNode** pRoot, BSDataType data)
{
    assert(pRoot);

    if (NULL == *pRoot)
        return false;
    else
    {

        if (data > (*pRoot)->_data)
        {
            return DelectBSTreeNor(&(*pRoot)->_pRight, data);
        }
        else if (data < (*pRoot)->_data)
        {
            return DelectBSTreeNor(&(*pRoot)->_pLeft, data);
        }
        else //data == (*pRoot)->_data
        {
            //這時已經找到了待刪除結點
            BSTNode* pDel = *pRoot;
            if (NULL == pDel->_pLeft)
            {
                *pRoot = pDel->_pRight;
                free(pDel);
                return true;
            }
            else if (NULL == (*pRoot)->_pRight)
            {
                *pRoot = pDel->_pLeft;
                free(pDel);
                return true;
            }
            else //左右孩子都存在
            {
                BSTNode* Inorder = pDel->_pRight;
                while (Inorder->_pLeft)
                    Inorder = Inorder->_pLeft;
                pDel->_data = Inorder->_data;
                return DelectBSTreeNor(&(*pRoot)->_pRight, pDel->_data);
            }
        }
    }
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"BSTree.h"

int main()
{
    BSTNode* pRoot;
    InitBSTree(&pRoot);
    int i = 0;
    for (i = 0; i < 5; i++)
    {
        InsertBSTreeNor(&pRoot, i);
    }
    //DestroyBSTree(&pRoot);
    InOrder(pRoot);
    BSTNode* ret = FindBSTreeNor(pRoot, 4);
    printf("\n");
    DelectBSTreeNor(&pRoot, 3);
    InOrder(pRoot);
    printf("\n");
    if (ret)
    {
        printf("該元素在二叉樹中\n");
    }
    else
    {
        printf("該元素不在二叉樹中\n");
    }

    return 0;
}

二叉搜尋樹的建立，插入，查詢過程實現

基於順序查詢資料隨機：順序查詢，遍歷時間複雜度O(N）資料已序：二分查詢，時間複雜度O(log2^N) 索引順序：資料量大，建立靜態索引基於樹形查詢二叉樹：二叉搜尋樹，二叉平衡樹多叉樹： B-樹，B+樹，B*樹基於雜湊查詢雜湊：雜湊表，雜

二叉排序樹的構造，插入，刪除，完整c程式碼實現

#include <stdio.h> #include <stdlib.h> typedef struct BiTNode{ int data; s

C語言實現連結串列的建立，初始化，插入，刪除，查詢

#include <stdio.h> #include <stdlib.h> #define OK 0 #define ERROR -1 #define MALLOC_ERROR -2 typedef int

二叉搜尋樹的初始化、插入、刪除、查詢、銷燬等操作

二叉搜尋樹的概念二叉搜尋樹又稱二叉排序樹，它或者是一顆空樹，或者是具有以下性質的二叉樹：若它的左子樹不為空，則左子樹上所有結點的值都小於根結點的值若它的右子樹不為空，則右子樹上所有結點的值都大於根結點的值它的左右子樹也分別為二叉搜尋樹例：

【演算法】【python實現】二叉搜尋樹插入、刪除、查詢

二叉搜尋樹定義：如果一顆二叉樹的每個節點對應一個關鍵碼值，且關鍵碼值的組織是有順序的，例如左子節點值小於父節點值，父節點值小於右子節點值，則這棵二叉樹是一棵二叉搜尋樹。類（TreeNode）：定義二叉搜尋樹各個節點在該類中，分別存放節點本身的值，以及其左子節點，右子節點，父節點的值。 clas

Java 實現二叉搜尋樹的建立、查詢、插入、刪除結點

二叉搜尋樹特點：左孩子結點值比當前結點值小，右孩子結點值比當前值大或等於當前值。本文假設樹中的結點值不存在相同的兩項或多項。一、二叉搜尋樹的建立 1、首先定義結點類程式碼如下： class TreeNode{ public int iData;

二叉搜尋樹的查詢、插入與刪除操作（Binary Search Tree, Search, Insert, Delete）（C++）

一、概念設 x 是二叉搜尋樹中的一個結點。如果 y 是 x 左子樹中的一個結點，那麼 y.key ≦ x.key。如果 y 是 x 右子樹中的一個結點，那麼 y.key ≧ x.key。

資料結構與演算法之二叉搜尋樹插入、查詢與刪除

1 二叉搜尋樹（BSTree）的概念　　二叉搜尋樹又被稱為二叉排序樹，那麼它本身也是一棵二叉樹，那麼滿足以下性質的二叉樹就是二叉搜尋樹，如圖：若左子樹不為空，則左子樹上所有節點的值都小於根節點的值；若它的右子樹不為空，則它的右子樹上所有節點的值都大於

二叉搜尋樹的查詢、最值查詢、插入和刪除

對於一棵二叉搜尋樹，如果不為空，它應該滿足以下三個特點：1、樹上的任一結點，該結點的值都大於它的非空左子樹的值。2、樹上的任一結點，該結點的值都小於它的非空右子樹的值。3、任一結點的左右子樹都是二叉搜尋樹。對於二叉搜尋樹的查詢，思路方法是：1、從根結點開始查詢，如果樹為空，就

二叉搜尋樹的查詢、插入、刪除操作

定義：二叉排序樹或者是一棵空樹，或者是具有下列性質的二叉樹：（1）若左子樹不空，則左子樹上所有結點的值均小於它的根結點的值；（2）若右子樹不空，則右子樹上所有結點的值均大於它的根結點的值；（3）左、右子樹也分別為二叉排序樹；（4）沒有鍵值相等的結點

二叉搜尋樹Java實現（查詢、插入、刪除、遍歷）

1 class Node { 2 int key; 3 int value; 4 Node leftChild; 5 Node rightChild; 6 7 public Node(int key, int value) { 8

二叉搜尋樹的插入、刪除、查詢等操作：Java語言實現

1 二叉搜尋樹介紹二叉搜尋樹（BST， Binary Search Tree），也稱二叉排序樹或二叉查詢樹。二叉搜尋樹：一棵二叉樹，可以為空；如果不為空，滿足以下性質：1. 非空左子樹的所有鍵值小於其根結點的鍵值。2. 非空右子樹的所有鍵值大於其根結點的鍵值。3. 左、右子

二叉搜尋樹(BST)的建立、插入、查詢和刪除

樹的結構體定義 struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 插入因為二叉搜

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

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

二叉搜尋樹的定義、查詢、插入和刪除

二叉搜尋樹的定義二叉搜尋樹，也稱有序二叉樹,排序二叉樹，是指一棵空樹或者具有下列性質的二叉樹： 1. 若任意節點的左子樹不空，則左子樹上所有結點的值均小於它的根結點的值； 2. 若任意節點的右子樹不空，則右子樹上所有結點的值均大於它的根結點的值； 3. 任意節

（二叉樹）二叉搜尋樹的查詢、插入和刪除

1.二叉搜尋樹簡介二叉搜尋樹或者是一棵空樹，或者是具有下列性質的二叉樹：若它的左子樹不空，則左子樹上所有結點的值均小於它的根結點的值；若它的右子樹不空，則右子樹上所有結點的值均大於它的根結點的值；它的左、右子樹也分別為二叉搜尋樹。二叉搜尋樹的特點之一即是其中序遍歷為升序。 2

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

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

（C語言）BinarySrearchTree二叉搜尋樹 --- 標準插入（遞迴，非遞迴）、遍歷（前，中，後序）、查詢（遞迴，非遞迴）、根插入遞迴（左旋，右旋）、最小最大值、刪除節點

1 #include <stdio.h> 2 #include <stdlib.h> 3 4 struct node{ 5 int data; 6 struct node *left; 7

二叉搜尋樹的查詢、插入、刪除的遞迴與非遞迴實現（C語言）

【概念】什麼是二叉搜尋樹？二叉搜尋樹又稱二叉排序樹（按照中序遍歷，可以得到一組有序的序列），它或者是一顆空樹，或者是具有以下性質的二叉樹：若他的左子樹不為空，則左子樹上所有節點的值都小於根結點的值。若他的

Leetcode 96 95 不同的二叉搜尋樹(動態規劃、搜尋樹)　不同的二叉搜尋樹II (遞迴、搜尋樹)

1.不同的二叉搜尋樹給定一個整數 n，求以 1 … n 為節點組成的二叉搜尋樹有多少種？示例: 輸入: 3 輸出: 5 解釋: 給定 n = 3, 一共有 5 種不同結構的二叉搜尋樹: 1 3 3 2 1 \

二叉搜尋樹的初始化、插入、刪除、查詢、銷燬等操作

二叉搜尋樹的概念

相關推薦