2. 程式人生 > >二叉排序樹C++實現

二叉排序樹C++實現

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

簡介

學習了演算法導論12章關於二叉排序樹的內容，自己利用C++實現了二叉排序樹的封裝。由此對二叉樹這種資料結構理解更加深刻了，對於遞迴在樹中的應用之廣更是有深切體會，例如遞迴建立，遞迴前，中，後序遍歷，返回樹高（個人最喜歡這個樹高遞迴函式，一句話返回樹高確實酷），遞迴刪除等……因為很多樹本身就是遞迴定義的。（刪除某節點比較難，有3,4種情況要分別考慮，暫時沒有實現，後續再補吧）
有什麼不足之處希望不吝賜教！

具體實現

標頭檔案二叉排序樹類的定義

註釋比較清楚，就不再贅述了：

#pragma once

#include<iostream>
using namespace std;

//樹節點定義，包含父節點指標（便於回溯前驅與後繼）
 

typedef struct Node {
    int data;
    struct Node *leftchild;
    struct Node *rightchild;
    struct Node *parent;
}Node_t;

/*
二叉排序樹類定義
*/
class BSearchTree{
 public:
    BSearchTree(void);  
    ~BSearchTree(void);

    inline Node_t* getRoot() const { return this->root;} 

    void createBSTree(int
 
 *dataset, int size); //建立二叉排序樹
    bool insertNode(Node_t **root, int value); //插入新節點,需要傳入二級指標（改變根指標的值）

    void inorderTraverse(Node_t *root) const;  //中序遍歷
    void visitMiddleOrder() const;  //對上一函式繼續封裝

    Node_t* searchNode(Node_t *root,int value) const; //按值查詢
    void searchByValue(int value) const; //對上一函式繼續封裝
 


    //最大與最小程式碼對稱
    void getMax(Node_t *root) const; //獲取最大值
    void getMin(Node_t *root) const; //獲取最小值

    //前驅與後繼程式碼對稱
    void getPredecessor(Node_t *node); //獲取節點前驅 
    void getSuccessor(Node_t *node); //獲取節點後繼

    int getHeight(Node_t *root) const; //返回樹高

 private:
     Node_t *root; //根節點
};

成員函式的實現：

#include "BSearchTree.h"


BSearchTree::BSearchTree(void)
{
    root = NULL;
}


BSearchTree::~BSearchTree(void)
{
    //to do sth
}

//建立二叉排序樹（匯入陣列內元素，逐一插入）
void BSearchTree:: createBSTree(int *dataset, int size) {
    for ( int i=0; i<size; i++ ) {
        insertNode(&root,dataset[i]);
    }
}


//插入新節點
//注意因為要修改root根指標的值，所以需要傳入二級指標
bool BSearchTree:: insertNode(Node_t **root, int value) {
    //初始化將插入的新節點
    Node_t *new_node = new Node_t;
    if ( new_node == NULL ) {
        return false;   
    }
    new_node->data = value;
    new_node->leftchild = new_node->rightchild = new_node->parent = NULL; 

    //空樹時，直接讓根指標指向新節點
    if( (*root) == NULL ) {
        *root = new_node;
        return true;
    }

     //插入到當前結點（*root）的左孩子  
    if ((*root)->leftchild == NULL && (*root)->data > value ) {
        new_node->parent = (*root);
        (*root)->leftchild = new_node;
        return true;
    }

     //插入到當前結點（*root）的右孩子  
    if((*root)->rightchild == NULL && (*root)->data < value){  
        new_node->parent = (*root);  
        (*root)->rightchild = new_node;  
        return true;  
    }  

    //遞迴法插入新節點
    if ( (*root)->data > value ) {  //新節點的值小於根節點，遞迴尋找左邊空位
        insertNode( &(*root)->leftchild,value);  //關鍵點

    }
    else if ( (*root)->data < value ) {  //新節點的值大於根節點，遞迴尋找右邊空位
        insertNode( &(*root)->rightchild,value); 

    } else {
        return true;
    }
}

//中序遍歷
void BSearchTree:: inorderTraverse(Node_t *root) const {
    //遞迴出口
    if ( root == NULL ) {
        return;
    }
    inorderTraverse( root->leftchild );
    cout<< root->data <<" ";
    inorderTraverse( root->rightchild );
}
void BSearchTree::visitMiddleOrder() const {
    inorderTraverse(this->root);
}

//按值查詢,返回節點的地址
Node_t* BSearchTree:: searchNode(Node_t *root,int value) const {
    if ( root == NULL ) {
        return NULL;
    }

    if ( root->data > value ) {
        searchNode( root->leftchild,value);

    }
    else if ( root->data < value ) {
        searchNode( root->rightchild,value);

    } else {
        return root;
    }
}
void BSearchTree:: searchByValue(int value) const{
    Node_t *p_findnode = this->searchNode(root,value);
    if ( p_findnode == NULL ) {
        cout<<"沒有找到該節點"<<endl;
    } else {
        cout<< "該節點存在" <<endl;
    }
}

//獲取最大值
void BSearchTree:: getMax(Node_t *root) const {
    while( root->rightchild ) {
        root = root->rightchild;
    }
    cout<<root->data<<endl;
}

//獲取最小值
void BSearchTree:: getMin(Node_t *root) const {
    while( root->leftchild ) {
        root = root->leftchild;
    }
    cout<<root->data<<endl;
}

//獲取節點前驅
void BSearchTree:: getPredecessor(Node_t *node) {
    //節點如果有左子樹，則其前驅節點是左子樹的最大值
    if ( node->leftchild != NULL ) {
        return getMax( node->leftchild );
    } else {
        cout<<"(該點無左子樹，開始回溯祖先...)"<<endl;
    }

    //如果沒有右子樹，則向上回溯，最頂層的祖先節點則是後繼
    Node_t *y = node->parent; //y首先指向該節點的父節點
    while( y != NULL && node == y->leftchild ) {
        node = y;
        y = y->parent;
    }
    cout<<y->data;
}

//獲取節點後繼
void BSearchTree:: getSuccessor(Node_t *node) {
    //節點如果有右子樹，則其後繼節點是右子樹的最小值
    if ( node->rightchild != NULL ) {
        return getMin( node->rightchild );
    } else {
        cout<<"(該點無右子樹，開始回溯祖先...)"<<endl;
    }

    //如果沒有右子樹，則向上回溯，最頂層的祖先節點則是後繼
    Node_t *y = node->parent;
    while( y != NULL && node == y->rightchild ) { //遇到第一個“拐角”回溯結束
        node = y;  //節點向上爬一層
        y = y->parent; //y也向上逐層回溯祖先
    }
    cout<<y->data;
}

//返回樹高,樹通用寫法
//ps：演算法導論認為只有一個根節點時樹高為0，我們常認為1
int BSearchTree::getHeight(Node_t *root) const {
    return root ?  max(getHeight(root->leftchild),getHeight(root->rightchild))+1 : -1;
}

測試程式碼：

#include"BSearchTree.h"


void main(void) {
     int arrs[] = { 14,2,4,10,3,5,8,23,18,35 };
    //int arrs[] = { 23, 65, 12, 3, 8, 76,  90, 21, 75, 34,345, 61 };
    int len = sizeof(arrs) / sizeof(arrs[0]);
    BSearchTree bsearch_tree;
    bsearch_tree.createBSTree(arrs,len);

    cout<<"中序遍歷結果： ";
    bsearch_tree.visitMiddleOrder();
    cout<<endl;

    cout<<"尋找節點3..."<<endl;
    bsearch_tree.searchByValue(3);
    cout<<endl;
    cout<<"尋找節點100..."<<endl;
    bsearch_tree.searchByValue(100);
    cout<<endl;

    cout<<"max :";
    bsearch_tree.getMax(bsearch_tree.getRoot());
    cout<<"min :";
    bsearch_tree.getMin(bsearch_tree.getRoot());
    cout<<endl;


    cout<<"樹高："<< bsearch_tree.getHeight(bsearch_tree.getRoot())<<endl<<endl;

    Node_t *pnext = bsearch_tree.searchNode(bsearch_tree.getRoot(),4);
    cout<<"節點"<<pnext->data<<"的後繼為：";
    bsearch_tree.getSuccessor(bsearch_tree.searchNode(bsearch_tree.getRoot(),4));

    pnext = bsearch_tree.searchNode(bsearch_tree.getRoot(),8);
    cout<<"節點"<<pnext->data<<"的後繼為：";
    bsearch_tree.getSuccessor(bsearch_tree.searchNode(bsearch_tree.getRoot(),8));
    cout<<endl;

    cout<<endl;

    Node_t *pbefore = bsearch_tree.searchNode(bsearch_tree.getRoot(),14);
    cout<<"節點"<<pbefore->data<<"的前驅為：";
    bsearch_tree.getPredecessor(bsearch_tree.searchNode(bsearch_tree.getRoot(),14));

    pbefore = bsearch_tree.searchNode(bsearch_tree.getRoot(),18);
    cout<<"節點"<<pbefore->data<<"的前驅為：";
    bsearch_tree.getPredecessor(bsearch_tree.searchNode(bsearch_tree.getRoot(),18));
    cout<<endl;


    system("pause");
}

執行結果：

這裡寫圖片描述

相關推薦

二叉排序樹C++實現

簡介 學習了演算法導論12章關於二叉排序樹的內容，自己利用C++實現了二叉排序樹的封裝。由此對二叉樹這種資料結構理解更加深刻了，對於遞迴在樹中的應用之廣更是有深切體會，例如遞迴建立，遞迴前，中，後序遍歷，返回樹高（個人最喜歡這個樹高遞迴函式，一句話返回樹高確實

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

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

二叉排序樹C語言實現

目錄 目錄 說明 程式碼 一些思考 說明 用C語言實現資料結構，二叉排序樹，可動態插入二叉樹結點，

C語言二叉排序樹的實現

二叉排序樹是一種排序和查詢都很有用的特殊二叉樹。 二叉樹的性質： 1.      若它的左子樹不為空，則左子樹上所有結點的值均小於它的根節點的值。 2.      若它的右子樹不為空，則右子樹上所有節點的值均大於它的根節點的值。 3.      他的左右子樹也是二叉排序樹。

二叉排序樹C語言實現一

一、定義：   二叉排序樹（二叉搜尋樹、二叉查詢樹）或者是空樹，或者滿足以下性質：` （1）若它的左子樹非空，則左子樹上所有記錄的值均小於根記錄的值； （2）若它的右子樹非空，則右子樹上所有記錄的值均大於根記錄的值； （3）左、右子樹本身又各是一顆二叉排序樹。     ——

二叉排序樹 C++

二叉查找樹 {} 刪除元素 one dem trees system arc oid 二叉排序樹（Binary Sort Tree）,又稱二叉查找樹。 1、若左子樹不為空，則左子樹上所有結點的值均小於他的根結構的值； 2、若右子樹不為空，則右子樹上所有結點的值均大於他的根結

二叉排序樹 python實現

class BTNode: def __init__(self, data, left, right): self.data = data

二叉排序樹程式碼實現

參照《大話資料結構》 313 ~328頁 #include <iostream> #include <stdio.h> #include <stdlib.h> #include <string.h> using names

演算法練習之二叉查詢樹 C++實現

/////////////////Tnode.h//////////////// class TNode { public: ////methods TNode(void); TNode(int data); ~TNode(void);

用java構建二叉排序樹，實現先序，中序和後序遍歷

1.基礎知識： 先上圖，舉個例子： 先選遍歷的規則：根節點----左子樹----右子樹      結果為12-9-76-35-22-16-48-46-40-90 中序遍歷的規則：左子樹--

AVL平衡樹(二叉搜尋樹 c++實現)

                平衡查詢樹 程式碼: 指標實現 /*仿一個部落格的AVL*/ #include<iostream> #include<cstdlib> #include<cstdio> #include<al

二叉查詢樹 C++實現

二叉查詢樹的C++實現 二叉查詢樹（BST）是父節點的值比左兒子的值大，比右兒子的值小的一種二叉樹。其資料元素集合包括每個節點，每個節點又包含節點的值和它的左兒子和右兒子。基本操作有：構造空的BST；判空；查詢；插入；刪除和遍歷。可以採用遞迴的方法來定義這些操

二叉排序樹C++構造

初次嘗試使用C++來構造二叉排序樹 定義： 二叉排序樹或者是一顆空樹，或者是具有以下性質的樹 1.左子樹（如果存在）上的所有節點的關鍵字都小於根節點的關鍵字 2.右子樹（如果存在）上的所有節點的關鍵字都大於根節點的關鍵字 3.左子樹和右子樹也是二叉排序

二叉排序樹 C語言原始碼 插入 查詢 刪除

二叉排序樹，詳細概念略過，參考資料結構書籍；詳細程式碼如下：（以下程式碼，均可直接執行） 儲存結構：二叉連結串列 typedef struct SOSTree { int data; struct SOSTree *LChild, *RChild

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

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

[原始碼和文件分享]基於C++實現的二叉排序樹

一、使用說明 1.1 專案簡介 依次輸入關鍵字並建立二叉排序樹，實現二叉排序樹的插入和查詢功能。 1.2 專案功能要求 二叉排序樹就是指將原來已有的資料根據大小構成一棵二叉樹，二叉樹中的所有結點資料滿足一定的大小關係，所有的左子樹中的結點均比根結點小，所有的右子樹的結點均比根結點大。

C++實現二叉排序樹

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

資料結構之二叉排序樹（C語言實現）

一、基本概念1.二叉排序樹        二叉排序樹（Binary sort tree，BST），又稱為二叉查詢樹，或者是一棵空樹；或者是具有下列性質的二叉樹：        (1)若它的左子樹不為空，則左子樹上所有節點的值均小於它的根節點的值；        (2)若它的右

資料結構之---C語言實現二叉排序樹（BinarySortTree）

wechat:812716131 ------------------------------------------------------ 技術交流群請聯絡上面wechat ----------------------------------------------

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

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