2. 程式人生 > >資料結構-查詢二叉樹

資料結構-查詢二叉樹

阿新 • • 發佈：2019-02-15

查詢二叉樹：始終滿足任一節點的左兒子小於該節點，右兒子大於該節點，

由於其特性，查詢二叉樹的中序遍歷始終為從小到大；

需要注意的是二叉查詢樹的刪除，有2種策略，在刪除節點不多時可以採用懶惰刪除，即標記該節點刪除而非真正的delete，第二種是當刪除節點只有一個兒子或則為葉子節點即沒有兒子時，可直接刪除並將兒子移至該節點，而當刪除節點有左右兒子時將其右子樹最小的節點移動至該節點，當然這裡並非真正的移動而是將目標節點的值賦給他，並刪除目標節點，這裡選用右子樹最小的節點可以保證不破壞查詢二叉樹的特性，

另外需要掌握的是由中序前序推出後序或則由中序後序推前序

/***********************************************
     >  Filename: BST.cpp
     >  Author:   Pyt
     >  Create:   2017-08-04 11:11:03
************************************************/

#include <iostream>
#include <queue>
#include <utility>
using namespace std;

template<typename T>
class BST{
public:
    BST();
    ~BST();
    BST(const BST &t);
    BST& operator=(const BST &t);

    void insert(const T &val);
    void remove(const T &val);
    void clear();
    bool empty() const;
    bool contains(const T &val) const;
    
    void inorder();
    void levelorder() const;

    T findMin() const;
    T findMax() const;

private:
    struct Node{
        T val;
        Node *left;
        Node *right;
        Node(T x, Node *l = NULL, Node *r = NULL) : val(x), left(l), right(r){}
    };
    Node *root;
    
    void insert(const T &val, Node *&t);
    void remove(const T &val, Node *&t);
    void clear(Node *&t);
    bool contains(const T &val, Node *&t) const;

    void inorder(Node *&t) const;
    Node* copy_tree(Node *t);

    Node* findMin(Node *t) const;
    Node* findMax(Node *t) const;
};
/**建構函式****/
template<typename T>
BST<T>::BST()
 : root(NULL)
{

}
/***析構*****/
template<typename T>
BST<T>::~BST()
{
    clear();
}
/***拷貝賦值****/
template<typename T>
BST<T>::BST(const BST &t)
{
    root = copy_tree(t.root);
}
/****賦值過載****/
template<typename T>
BST<T>& BST<T>::operator=(const BST &t)
{
    if(this != &t)
    {
        clear();
        root = copy_tree(t.root);
    }
    return *this;
}
/**插入***/
template<typename T>
void BST<T>::insert(const T &val)
{
    insert(val, root);
}
/***刪除*****/
template<typename T>
void BST<T>::remove(const T &val)
{
    remove(val, root);
}
/****清空查詢樹****/
template<typename T>
void BST<T>::clear()
{
    clear(root);
}
/***判斷樹是否為空***/
template<typename T>
bool BST<T>::empty() const
{
    return root==NULL;
}
/****判斷是否包含某元素****/
template<typename T>
bool BST<T>::contains(const T &val) const
{
    return contains(val, root);
}
/***中序遍歷****/
template<typename T>
void BST<T>::inorder()
{
    inorder(root);
}
/***層序遍歷****/
template<typename T>
void BST<T>::levelorder() const
{
    int curlevel = 0;
    queue<pair<Node*, int>> q;
    if(root)
      q.push(make_pair(root, 0));
    while(!q.empty())
    {
        pair<Node*, int> tmp = q.front();
        q.pop();
        if(tmp.second > curlevel)
        {
            cout << endl;
            curlevel = tmp.second;
        }
        cout << tmp.first->val << " ";
        if(tmp.first->left)
          q.push(make_pair(tmp.first->left, curlevel+1));
        if(tmp.first->right)
          q.push(make_pair(tmp.first->right, curlevel+1));
    }
    cout << endl;
}
/***獲取最小元值****/
template<typename T>
T BST<T>::findMin() const
{
    if(root)
        return findMin(root)->val;
}
/****獲取最大元值****/
template<typename T>
T BST<T>::findMax() const
{
    if(root)
        return findMax(root)->val;
}
/***尋找插入私有函式****/
template<typename T>
void BST<T>::insert(const T &val, Node *&t)
{

    if(t == NULL)
      t = new Node(val);
    if(val < t->val)
      insert(val, t->left);
    else if(val > t->val)
      insert(val, t->right);
}
/****尋找刪除私有函式****/
template<typename T>
void BST<T>::remove(const T &val, Node *&t)
{
    if(t == NULL)
      return ;
    if(val < t->val)
      remove(val, t->left);
    else if(val > t->val)
      remove(val, t->right);
    else
    {
        if(t->left && t->right)
        {
            t->val = findMin(t->right)->val;
            remove(val, t->right);
        }
        else{
            Node *obj = t;
            t = t->left ? t->left : t->right;
            delete obj;
        }
    }
}
/****清空樹私有函式*****/
template<typename T>
void BST<T>::clear(Node *&t)
{
    if(t)
    {
        clear(t->left);
        clear(t->right);
        delete t;
    }
    t = NULL;
}
/***查詢是否包含元素私有函式****/
template<typename T>
bool BST<T>::contains(const T &val, Node *&t) const
{
    if(t == NULL)
      return false;
    else if(val < t->val)
      return contains(val, t->left);
    else if(val > t->val)
      return contains(val, t->right);
    else 
      return true;
}
/***中序遍歷私有函式****/
template<typename T>
void BST<T>::inorder(Node *&t) const
{
    if(t)
    {
        inorder(t->left);
        cout << t->val << " ";
        inorder(t->right);
    }
}
/****深拷貝樹私有函式*****/
template<typename T>
typename BST<T>::Node* BST<T>::copy_tree(Node *t)
{
    if(t == NULL)
      return NULL;
    else
      return new Node(t->val, copy_tree(t->left), copy_tree(t->right));
}
/**找到最小節點私有函式***/
template<typename T>
typename BST<T>::Node* BST<T>::findMin(Node *t) const
{
    if(t->left == NULL)
      return t;
    else
      return findMin(t->left);
}
/***找到最大節點私有函式****/
template<typename T>
typename BST<T>::Node* BST<T>::findMax(Node *t) const
{
    if(t->right == NULL)
      return t;
    else
      return findMax(t->right);
}

int main()
{
    BST<int> a;
    a.insert(8), a.insert(6), a.insert(5), a.insert(7), a.insert(3), a.insert(9), a.insert(7);
    a.levelorder();
    a.remove(6);
    a.levelorder();
    BST<int> b(a);
    b.levelorder();
    BST<int> c;
    c = a;
    c.levelorder();
    c.inorder();
    cout << endl;
    cout << a.findMax() << " " << a.findMin() << endl;
    c.clear();
    cout << c.empty() << endl;
}


相關推薦

資料結構-查詢二叉樹

查詢二叉樹：始終滿足任一節點的左兒子小於該節點，右兒子大於該節點， 由於其特性，查詢二叉樹的中序遍歷始終為從小到大； 需要注意的是二叉查詢樹的刪除，有2種策略，在刪除節點不多時可以採用懶惰刪除，即標記該節點刪除而非真正的delete，第二種是當刪除節點只有一個兒子或則為葉子

【演算法與資料結構】二叉樹查詢

目錄 概要 樹的介紹 二叉樹的介紹 二叉查詢樹的C實現 1. 節點定義 2 遍歷 3. 查詢 4. 最大值和最小值 5. 前驅和後繼 6. 插入 7. 刪除 8. 列印 9. 銷燬二叉樹 完整的實現程式碼 二叉查詢樹的C測試程式 下面對

Python資料結構之二叉樹（涵蓋了構建、刪除、查詢、字典轉換、非遞迴與遞迴遍歷等）

MyTree.py #coding=utf-8 import math class BinTree: def __init__(self): self.root=None def is_empty(self):

資料結構——線索二叉樹（程式碼）

線索二叉樹 C++ 環境codeblocks17 通過 /* 線索二叉樹 @CGQ 2018/10/29 */ #include <iostream> #include <stdio.h> #include <stdlib.h> using namesp

【資料結構】二叉樹的相關操作（待更）

#include "stdio.h" #include "stdlib.h" typedef struct node { char data; struct node *rchild,*lchild; }bintnode; typedef bintnode *bintree;//指向該結構體

資料結構 互換二叉樹中所有結點的左右子樹 C

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

資料結構作業——————二叉樹的三種遍歷方式

資料結構作業： 二叉樹的建立 三種遍歷方式 L：遍歷左子樹 D：訪問根節點 R：遍歷右子樹 DLR：先序遍歷 LDR：中序遍歷 LRD：後序遍歷 #include<bits/stdc++.h> using namespace std

【資料結構】二叉樹的建立和遍歷（非遞迴）

該程式使用的是遞迴地建立方法，以及非遞迴的遍歷演算法 執行環境：Dev-C++ #include <stdio.h> #include <stdlib.h> typedef struct node{ char data; struct node *lchild

【資料結構】二叉樹的建立與遍歷（遞迴）

該程式全是使用遞迴的操作 執行環境是：Dev-C++ #include <stdio.h> #include <stdlib.h> typedef struct node{ char data; struct node *lchild,*rchild; }bi

今日分資料結構作業:二叉樹簡單操作

又是一次非常有趣(sangxinbingkuang)的作業。 這麼簡單的作業居然寫了一下午，我也是醉了。 看來下次要調整好狀態再寫作業了QAQ。 先看實驗要求： 後三道題懶得寫了，就不發要求了/滑稽。 程式碼(附帶詳細註釋)： import java.util.*;

C Primer Plus--高階資料結構之二叉樹

目錄 二叉搜尋樹 Binary Search Tree 用C構建二叉樹ADT 樹結構的定義 C Primer Plus--高階資料結構表示之二叉樹 二叉搜尋樹 Binary Search Tree 二叉樹是一種高階資料結構。樹中的每個節點都包含一個專案和兩個指向其他

【資料結構】二叉樹的應用

1、分別採用遞迴和非遞迴的方式編寫兩個函式，求一棵給定二叉樹中葉子節點的個數 2、返回一棵給定二叉樹在中序遍歷下的最後一個結點 3、假設二叉樹採用鏈式方式儲存，root為其根節點，p和q分別指向二叉樹中任意兩個結點，編寫一個函式，返回p和q最近的共同祖先。  #includ

資料結構——求二叉樹高度

這個題。。。有點迷。。。 首先注意題幹，人家讓你寫的是Getheight函式，那個構建樹那個函式 是被忽略掉不需要去寫的，一開始還在為怎麼去構建這個樹想了半天。。。。 裁判測試程式樣例： #include <stdio.h> #include <stdlib.h&g

資料結構——統計二叉樹的結點個數

統計二叉樹的結點個數 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct Node{ //二叉樹的鏈式儲存結點 char data; str

C++資料結構 16 二叉樹

樹集成了陣列和連結串列的優點（查詢速度快） 樹：結點，度，葉結點，父結點，子結點，兄弟結點，樹的度，樹的高度。 具體概念可以參考：https://blog.csdn.net/u012928324/article/details/61194190?utm_source=itdadao&am

【資料結構】二叉樹基本操作

文章目錄 BinaryTree.h BinaryTree.c Test.c 棧和佇列的相關函式: 棧：https://blog.csdn.net/weixin_41892460/article/details/82

資料結構——線索二叉樹的基本操作

線索二叉樹的基本操作 #include<stdio.h> #include<stdlib.h> typedef struct Node{ //二叉樹的鏈式儲存結點 char data; struct Node *Lchild; struct

資料結構學習——二叉樹遍歷

1 #include"stdio.h" 2 #include"stdlib.h" 3 #define maxsize 100 4 //二叉樹連結串列型別定義 5 typedef struct node{ 6 char data; 7 struct node

基於python的 樹型資料結構，二叉樹使用與AVL樹使用

樹由n個節點組成的集合，可以遞迴定義資料結構，如果n=0就是空樹 如果n>那麼有樹 概念 根節點、葉子節點 樹的深度（高度） 樹的度 孩子節點、父節點 子樹 二叉樹-遍歷 # 樹型圖示意 E

python資料結構之二叉樹

這裡用python 實現了二叉樹 # Definition for a binary tree node. class TreeNode: def __init__(self, x): self.val = x self.left =