2. 程式人生 > >資料結構——二叉查詢樹的詳細實現(c++)

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

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

本文實現了二叉查詢樹的前序遍歷（遞迴與非遞迴）、中序遍歷（遞迴與非遞迴）、後序遍歷（遞迴與非遞迴）、插入過程、刪除過程、查詢過程等。

二叉樹的簡單介紹：
1、二叉樹中的每個節點都不能有多餘兩個的兒子。
2、二叉樹的深度要比N小得多。

假設每個節點被指定一個關鍵字值（所有關鍵字是整數、互異的）。

二叉查詢樹的性質：
1、左子樹的所有節點值均小於根節點值。
2、右子樹的所有節點值均大於根節點值。
3、左右子樹都滿足上述兩個條件。

插入過程：
1、若當前二叉樹為空，則插入的元素為根節點。
2、若插入的元素值小於根節點值，則遞迴從根節點的左子樹中找到可插入位置。
3、若插入的元素值大於根節點值，則遞迴從根節點的右子樹中找到可插入位置。

刪除過程：
1、待刪除節點Z為葉子節點，則直接刪除該節點。修改父節點的指標。
2、待刪除節點Z為單支節點（只有左子樹或者右子樹），讓Z的子樹與Z的父節點相連，刪除節點Z。
3、待刪除節點Z左右子樹都不為空。
方法一：找到Z的後繼節點y，因為y一定沒有左子樹，所以可以直接刪除y，並讓y的父親節點成為y的右子樹的父親節點。用y替換Z。
方法二：找到Z的前驅節點x，x一定沒有右子樹，所以可以直接刪除x，並讓x的父親節點成為x的左子樹的父親節點。用x替換Z。

查詢過程：
1、若待查詢的元素值和根節點相同，則返回根節點。
2、若待查詢的元素值小於根節點的元素值，則遞迴從根節點的左子樹中查詢。
3、若待查詢的元素值大於根節點的元素值，則遞迴從根節點的右子樹中查詢。

遍歷過程：
1、前序遍歷（遞迴和非遞迴兩種）：先根節點，後左孩子節點，再右孩子結點。
2、中序遍歷（遞迴和非遞迴兩種）：先左孩子結點，後根節點，再右孩子結點。
3、後序遍歷（遞迴和非遞迴兩種）：先做孩子節點，後右孩子結點，再根節點。

獲取最大元素的節點：
1、如果根節點無右子樹，則返回根節點。
2、依次查詢根節點的右子樹節點，返回右子樹的最後一個右節點。

獲取最小元素的節點：
1、如果根節點無左子樹，則返回根節點。
2、依次查詢跟節點的左子樹節點，返回左子樹的最後一個左節點。

依次插入資料（15,3,20,8,10,18,6,1,26）之後的二叉樹結構如下：
這裡寫圖片描述

程式碼如下：

#include <iostream>
#include <stack>
using namespace std;

typedef struct STreeNode* pSTreeNode;
typedef int TreeKeyType;

struct STreeNode 
{
    TreeKeyType key;
    pSTreeNode pLeftChild;
    pSTreeNode pRightChild;

    STreeNode( TreeKeyType Value )
    {
        key = Value;
        pLeftChild = NULL;
        pRightChild = NULL;
    }
};

class CBinTree
{
public:
    CBinTree();
    ~CBinTree();

    void Insert( TreeKeyType Value );
    void Insert( pSTreeNode pNode, TreeKeyType Value );

    pSTreeNode Search( TreeKeyType Value );
    pSTreeNode Search( pSTreeNode pNode, TreeKeyType Value );

    void Delete( TreeKeyType Value );

    void Preorder( );       //  前序遍歷,非遞迴方法（借用堆疊）
    void Inorder( );        //  中序遍歷,非遞迴方法（借用堆疊）
    void Postorder( );      //  後序遍歷,非遞迴方法（借用堆疊）

    void PreorderRecursively( pSTreeNode pNode );   //  前序遍歷，遞迴呼叫
    void InorderRecursively( pSTreeNode pNode );    //  中序遍歷，遞迴呼叫
    void PostorderRecursively( pSTreeNode pNode );  //  後序遍歷，遞迴呼叫

    pSTreeNode GetMaxKey();     //  獲得二叉查詢樹中元素值最大的節點
    pSTreeNode GetMinKey();     //  獲得二叉查詢樹中元素值最小的節點

    void FreeMemory( pSTreeNode pNode );    //  釋放記憶體
public:
    pSTreeNode pRoot;
};

CBinTree::CBinTree()
{
    pRoot = NULL;
}

CBinTree::~CBinTree()
{
    if ( pRoot == NULL )
        return;

    FreeMemory( pRoot );
}

void CBinTree::FreeMemory( pSTreeNode pNode )
{
    if ( pNode == NULL )
        return;

    if ( pNode->pLeftChild != NULL )
        FreeMemory( pNode->pLeftChild );

    if ( pNode->pRightChild != NULL )
        FreeMemory( pNode->pRightChild );

    delete pNode;
    pNode = NULL;
}

void CBinTree::Insert( TreeKeyType Value )
{
    if ( pRoot == NULL )
        pRoot = new STreeNode( Value );
    else
        Insert( pRoot, Value );
}

void CBinTree::Insert( pSTreeNode pNode, TreeKeyType Value )
{
    if ( pNode->key > Value )
    {
        if ( pNode->pLeftChild == NULL)
            pNode->pLeftChild = new STreeNode( Value );
        else
            Insert( pNode->pLeftChild, Value );
    }
    else
    {
        if ( pNode->pRightChild == NULL)
            pNode->pRightChild = new STreeNode( Value );
        else
            Insert( pNode->pRightChild, Value );
    }
}

pSTreeNode CBinTree::Search( TreeKeyType Value )
{
    return Search( pRoot, Value );
}

pSTreeNode CBinTree::Search( pSTreeNode pNode, TreeKeyType Value )
{
    if ( pNode == NULL )
        return NULL;

    if ( pNode->key == Value )
        return pNode;
    else
    {
        if ( pNode->key > Value )
            return Search( pNode->pLeftChild, Value );
        else
            return Search( pNode->pRightChild, Value );
    }
}

void CBinTree::Delete( TreeKeyType Value )
{
    pSTreeNode pParentNode = pRoot;
    pSTreeNode pFindNode = pRoot;
    //  找到Value元素對應的節點
    while ( pFindNode != NULL )
    {
        if ( pFindNode->key == Value )
            break;

        pParentNode = pFindNode;
        if ( pFindNode->key > Value )
            pFindNode = pFindNode->pLeftChild;
        else
            pFindNode = pFindNode->pRightChild;
    }

    if ( pFindNode == NULL )
        return;


    //  處理Value元素的父節點和Value元素的節點
    if ( pFindNode->pLeftChild == NULL || pFindNode->pRightChild == NULL )
    {
        //  一個子結點為空或者兩個子結點都為空
        pSTreeNode pTemp = NULL;
        if ( pFindNode->pLeftChild != NULL)
            pTemp = pFindNode->pLeftChild;
        else if ( pFindNode->pRightChild != NULL )
            pTemp = pFindNode->pRightChild;

        if ( pParentNode->pLeftChild == pFindNode )
            pParentNode->pLeftChild = pTemp;
        else
            pParentNode->pRightChild = pTemp;

        delete pFindNode;
        pFindNode = NULL;
    }
    else
    {
        //  找到前驅節點
        pSTreeNode pTemp = pFindNode->pLeftChild;
        pSTreeNode pTempParent = pFindNode;

        while ( pTemp->pRightChild != NULL )
        {
            pTempParent = pTemp;
            pTemp = pTemp->pRightChild; 
        }

        pFindNode->key = pTemp->key;
        pTempParent->pRightChild = NULL;
        delete pTemp;
        pTemp = NULL;
    }
}

void CBinTree::Preorder(  )
{
    if ( pRoot == NULL )
    {
        cout << "二叉樹為空！" << endl;
        return;
    }

    stack<pSTreeNode> StackTree;
    pSTreeNode pNode = pRoot;
    while( pNode != NULL || !StackTree.empty())
    {
        while ( pNode != NULL )
        {
            cout << " " << pNode->key << " ";
            StackTree.push(pNode);
            pNode = pNode->pLeftChild;
        }

        pNode = StackTree.top();
        StackTree.pop();
        pNode = pNode->pRightChild;
    }

}

void CBinTree::Inorder( )
{
    if ( pRoot == NULL )
    {
        cout << "二叉樹為空！" << endl;
        return;
    }

    stack<pSTreeNode> StackTree;
    pSTreeNode pNode = pRoot;
    while ( pNode != NULL || !StackTree.empty() )
    {
        while ( pNode != NULL )
        {
            StackTree.push( pNode );
            pNode = pNode->pLeftChild;
        }

        pNode = StackTree.top();
        StackTree.pop();
        cout << " " << pNode->key << " ";
        pNode = pNode->pRightChild;
    }
}


//  藉助變數visited表示是否訪問過該根節點。訪問過的話，這輸出。
void CBinTree::Postorder( )
{
    if ( pRoot == NULL )
    {
        cout << "二叉樹為空！" << endl;
        return;
    }

    stack< pair<pSTreeNode, bool>> StackTree;
    StackTree.push( make_pair( pRoot, false ));

    while ( !StackTree.empty() )
    {
        pSTreeNode pNode = StackTree.top().first;
        bool bVisited = StackTree.top().second;


        if (pNode == NULL)
        {
            StackTree.pop();
            continue;
        }

        if (bVisited)
        {
            cout << " " << pNode->key << " ";
            StackTree.pop();
        }
        else
        {
            StackTree.top().second = true;
            StackTree.push( make_pair( pNode->pRightChild, false));
            StackTree.push( make_pair( pNode->pLeftChild, false));
        }
    }
}

void CBinTree::PreorderRecursively( pSTreeNode pNode )
{
    if (pNode == NULL)
        return;

    cout << " " << pNode->key << " ";
    PreorderRecursively( pNode->pLeftChild );
    PreorderRecursively( pNode->pRightChild );
}

void CBinTree::InorderRecursively( pSTreeNode pNode )
{
    if (pNode == NULL)
        return;

    InorderRecursively( pNode->pLeftChild );
    cout << " " << pNode->key << " ";
    InorderRecursively( pNode->pRightChild );
}

void CBinTree::PostorderRecursively( pSTreeNode pNode )
{
    if (pNode == NULL)
        return;

    PostorderRecursively( pNode->pLeftChild );
    PostorderRecursively( pNode->pRightChild );
    cout << " " << pNode->key << " ";
}

int main()
{
    CBinTree* pBinTree = new CBinTree();
    if ( pBinTree == NULL )
        return 0;

    pBinTree->Insert( 15 );
    pBinTree->Insert( 3 );
    pBinTree->Insert( 20 );
    pBinTree->Insert( 8 );
    pBinTree->Insert( 10 );
    pBinTree->Insert( 18);
    pBinTree->Insert( 6 );
    pBinTree->Insert( 1);
    pBinTree->Insert( 26);

    pSTreeNode pRoot = pBinTree->pRoot;

    cout << " 非遞迴前序遍歷   ：" ;
    pBinTree->Preorder();
    cout << endl;

    cout << " 遞迴前序遍歷    ：" ;
    pBinTree->PreorderRecursively( pRoot );
    cout << endl;

    cout << " 非遞迴中序遍歷   ：" ;
    pBinTree->Inorder();
    cout << endl;

    cout << " 遞迴中序遍歷    ：" ;
    pBinTree->InorderRecursively( pRoot );
    cout << endl;

    cout << " 非遞迴後序遍歷   ：" ;
    pBinTree->Postorder();
    cout << endl;

    cout << " 遞迴後續遍歷    ：";
    pBinTree->PostorderRecursively( pRoot );
    cout << endl;

    pSTreeNode pMaxNode = pBinTree->GetMaxKey();
    pSTreeNode pMinNode = pBinTree->GetMinKey();
    if ( pMaxNode != NULL )
        cout << " 該二叉查詢樹的最大元素是：" << pMaxNode->key << endl;

    if (pMinNode != NULL )
        cout << " 該二叉查詢樹的最小元素是：" << pMinNode->key << endl;

    TreeKeyType DeleteKey = 15;
    pSTreeNode pSearchNode = pBinTree->Search( DeleteKey );
    if ( pSearchNode != NULL )
        cout << " 需要查詢的元素是：" << DeleteKey << ", 實際查詢到的元素是：" << pSearchNode->key << endl;
    else
        cout << " 沒有查詢到元素" << DeleteKey << endl;
    pBinTree->Delete( DeleteKey );
    cout << " 刪除元素" << DeleteKey << "之後的遞迴前序遍歷：";
    pBinTree->PreorderRecursively( pRoot );
    cout << endl;

    DeleteKey = 1;
    pBinTree->Delete( DeleteKey );
    cout << " 刪除元素" << DeleteKey << "之後的遞迴前序遍歷：";
    pBinTree->PreorderRecursively( pRoot );
    cout << endl;

    DeleteKey = 8;
    pBinTree->Delete( DeleteKey );
    cout << " 刪除元素" << DeleteKey << "之後的遞迴前序遍歷：";
    pBinTree->PreorderRecursively( pRoot );
    cout << endl;

    DeleteKey = 26;
    pBinTree->Delete( DeleteKey );
    cout << " 刪除元素" << DeleteKey << "之後的遞迴前序遍歷：";
    pBinTree->PreorderRecursively( pRoot );
    cout << endl;

    delete pBinTree;
    pBinTree = NULL;
    system( "pause" );
    return 1;
}

執行結果如下：
這裡寫圖片描述

相關推薦

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

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

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

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

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

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

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

資料結構之二叉查詢樹Java實現原始碼及註釋

二叉查詢樹（Binary Search Tree），（又：二叉搜尋樹，二叉排序樹）它或者是一棵空樹，或者是具有下列性質的二叉樹： 若它的左子樹不空，則左子樹上所有結點的值均小於它的根結點的值； 若它的右子樹不空，則右子樹上所有結點的值均大於它的根結點的值； 它的左、右子樹也分別為二叉排序樹。以下是樓主用jav

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

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

資料結構——二叉排序樹

建立、查詢、刪除 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

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

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

資料結構: 二叉搜尋樹

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

AVL樹-自平衡二叉查詢樹(Java實現)

      在電腦科學中，AVL樹是最先發明的自平衡二叉查詢樹。AVL樹得名於它的發明者 G.M. Adelson-Velsky 和 E.M. Landis，他們在 1962 年的論文 "An algorithm for the organization of inform

二叉查詢樹的實現（插入+遞迴呼叫）

package BinaryTree; public class BinarySearchTree { public TreeNode root; public BinarySearchTree(){ //root=new TreeNode(1,"A");

二叉查詢樹python實現

1. 二叉查詢樹的定義： 左子樹不為空的時候，左子樹的結點值小於根節點，右子樹不為空時，右子樹的結點值大於根節點，左右子樹分別為二叉查詢樹 2. 二叉查詢樹的最左邊的結點即為最小值，要查詢最小值，只需遍歷左子樹的結點直到為空為止，同理，最右邊的結點結尾最大值，要查詢最大值，

資料結構-二路歸併-遞迴實現-C語言

/* * * 二路歸併 遞迴實現 * * * */ #include <stdio.h> #include <stdlib.h> //對一個元素或者多個有序元素進行合併 void Merge(int Element[],int TmpA[],int

建立二叉查詢樹的完整C程式碼

BST 基本概念 二叉查詢樹（Binary Search Tree），又稱二叉排序樹（Binary Sort Tree）。它或者是一棵空樹；或者是具有下列性質的二叉樹： （1）若左子樹不空，則左子樹上所有結點的值均小於它的根結點的值； （2）若右子樹不空，則右子樹上所有結

資料結構之 二叉查詢樹（C語言實現）

資料結構之 二叉查詢樹 1. 二叉查詢樹的定義 二叉查詢樹（binary search tree）是一棵二叉樹，或稱為二叉搜尋樹，可能為空；一棵非空的二叉查詢樹滿足一下特徵： 每個元素有一個關鍵字，並且任意兩個元素的關鍵字都不同；因此，所有的關鍵字都是唯

查詢演算法 淺談演算法和資料結構: 七 二叉查詢樹 淺談演算法和資料結構: 十一 雜湊表

閱讀目錄 1. 順序查詢 2. 二分查詢 3. 插值查詢 4. 斐波那契查詢 5. 樹表查詢 6. 分塊查詢 7. 雜湊查詢 　　查詢是在大量的資訊中尋找一個特定的資訊元素，在計算機應用中，查詢是常用的基本運算，例如編譯程式中符號表的查詢。本文

資料結構與演算法總結——二叉查詢樹及其相關操作

我實現瞭如下操作 插入，查詢，刪除，最大值 樹的高度，子樹大小 二叉樹的範圍和，範圍搜尋 樹的前序，中序，後序三種遍歷 rank 前驅值 在這一版本的程式碼中，我使用了類模板將介面與實現分

C++資料結構 17 二叉查詢樹

Bst(Binary Search Tree) 有以下性質： 每一個元素有一個鍵值，而且不予許重複 左子樹的鍵值都小於根節點的鍵值 右子樹的鍵值都大於根節點的鍵值 左右子樹都是二叉查詢樹 程式碼： #ifndef __BST_H__ #