資料結構開發(23)：二叉樹中結點的查詢、插入、刪除與清除操作

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

0.目錄

1.二叉樹中結點的查詢操作

2.二叉樹中結點的插入操作

3.二叉樹中結點的刪除操作

4.二叉樹中結點的清除操作

5.小結

1.二叉樹中結點的查詢操作

查詢的方式：

基於資料元素值的查詢
1. BTreeNode<T>* find(const T& value) const
基於結點的查詢
1. BTreeNode<T>* find(TreeNode<T>* node) const

樹中資料元素和結點的查詢：

基於資料元素值的查詢：

定義功能：find(node, value

)
1. 在 node 為根結點的二叉樹中查詢 value 所在的結點

在BTree.h中實現基於資料元素值的查詢：

protected:
    virtual BTreeNode<T>* find(BTreeNode<T>* node, const T& value) const
    {
        BTreeNode<T>* ret = NULL;

        if( node != NULL )
        {
            if( node->value == value )
            {
                return node;
            }
            else
            {
                if( ret == NULL )
                {
                    ret = find(node->left, value);
                }

                if( ret == NULL )
                {
                    ret = find(node->right, value);
                }
            }
        }

        return ret;
    }
public:
    BTreeNode<T>* find(const T& value) const
    {
        return find(root(), value);
    }

基於結點的查詢：

定義功能：find(node, obj)
1. 在 node 為根結點的二叉樹中查詢是否存在 obj 結點

在BTree.h中實現基於結點的查詢：

protected:
    virtual BTreeNode<T>* find(BTreeNode<T>* node, BTreeNode<T>* obj) const
    {
        BTreeNode<T>* ret = NULL;

        if( node == obj )
        {
            return node;
        }
        else
        {
            if( node != NULL )
            {
                if( ret == NULL )
                {
                    ret = find(node->left, obj);
                }

                if( ret == NULL )
                {
                    ret = find(node->right, obj);
                }
            }
        }

        return ret;
    }
public:
    BTreeNode<T>* find(TreeNode<T>* node) const
    {
        return find(root(), dynamic_cast<BTreeNode<T>*>(node));
    }

2.二叉樹中結點的插入操作

需要考慮的問題：

是否能夠在二叉樹的任意結點處插入子結點？
是否需要指定新資料元素 ( 新結點 ) 的插入位置？

二叉樹結點的位置列舉型別：

插入的方式

插入新結點
1. bool insert(TreeNode<T>* node)
2. bool insert(TreeNode<T>* node, BTNodePos pos)
插入資料元素
1. bool insert(const T& value, TreeNode<T>* parent)
2. bool insert(const T& value, TreeNode<T>* parent, BTNodePos pos)

新結點的插入：

指定位置的結點插入：

插入新結點：

插入資料元素：

在BTreeNode.h中實現BTNodePos列舉型別：

#ifndef BTREENODE_H
#define BTREENODE_H

#include "TreeNode.h"

namespace StLib
{

enum BTNodePos
{
    ANY,
    LEFT,
    RIGHT
};

template <typename T>
class BTreeNode : public TreeNode<T>
{
public:
    BTreeNode<T>* left;
    BTreeNode<T>* right;

    BTreeNode()
    {
        left = NULL;
        right = NULL;
    }

    static BTreeNode<T>* NewNode()
    {
        BTreeNode<T>* ret = new BTreeNode<T>();

        if( ret != NULL )
        {
            ret->m_flag = true;
        }

        return ret;
    }
};

}

#endif // BTREENODE_H

在BTree.h中實現結點的插入操作：

protected:
    virtual bool insert(BTreeNode<T>* n, BTreeNode<T>* np, BTNodePos pos)
    {
        bool ret = true;

        if( pos == ANY )
        {
            if( np->left == NULL )
            {
                np->left = n;
            }
            else if( np->right == NULL )
            {
                np->right = n;
            }
            else
            {
                ret = false;
            }
        }
        else if( pos == LEFT )
        {
            if( np->left == NULL )
            {
                np->left = n;
            }
            else
            {
                ret = false;
            }
        }
        else if( pos == RIGHT )
        {
            if( np->right == NULL )
            {
                np->right = n;
            }
            else
            {
                ret = false;
            }
        }
        else
        {
            ret = false;
        }

        return ret;
    }
public:
    bool insert(TreeNode<T>* node)
    {
        return insert(node, ANY);
    }

    virtual bool insert(TreeNode<T>* node, BTNodePos pos)
    {
        bool ret = true;

        if( node != NULL )
        {
            if( this->m_root == NULL )
            {
                node->parent = NULL;
                this->m_root = node;
            }
            else
            {
                BTreeNode<T>* np = find(node->parent);

                if( np != NULL )
                {
                    ret = insert(dynamic_cast<BTreeNode<T>*>(node), np, pos);
                }
                else
                {
                    THROW_EXCEPTION(InvalidParameterException, "Invalid parent tree node ...");
                }
            }
        }
        else
        {
            THROW_EXCEPTION(InvalidParameterException, "Parameter node can not be NULL ...");
        }

        return ret;
    }

    bool insert(const T& value, TreeNode<T>* parent)
    {
        return insert(value, parent, ANY);
    }

    virtual bool insert(const T& value, TreeNode<T>* parent, BTNodePos pos)
    {
        bool ret = true;
        BTreeNode<T>* node = BTreeNode<T>::NewNode();

        if( node == NULL )
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new node ...");
        }
        else
        {
            node->value = value;
            node->parent = parent;

            ret = insert(node, pos);

            if( !ret )
            {
                delete node;
            }
        }

        return ret;
    }

mian.cpp測試這棵樹：

#include <iostream>
#include "BTree.h"

using namespace std;
using namespace StLib;

int main()
{
    BTree<int> bt;
    BTreeNode<int>* n = NULL;

    bt.insert(1, NULL);

    n = bt.find(1);
    bt.insert(2, n);
    bt.insert(3, n);

    n = bt.find(2);
    bt.insert(4, n);
    bt.insert(5, n);

    n = bt.find(4);
    bt.insert(8, n);
    bt.insert(9, n);

    n = bt.find(5);
    bt.insert(10, n);

    n = bt.find(3);
    bt.insert(6, n);
    bt.insert(7, n);

    n = bt.find(6);
    bt.insert(11, n, LEFT);

    int a[] = {8, 9, 10, 11, 7};

    for(int i=0; i<5; i++)
    {
        TreeNode<int>* node = bt.find(a[i]);

        while( node )
        {
            cout << node->value << " ";
            node = node->parent;
        }

        cout << endl;
    }

    return 0;
}

執行結果為：

3.二叉樹中結點的刪除操作

刪除的方式：

基於資料元素值的刪除
1. SharedPointer< Tree<T> > remove(const T& value)
基於結點的刪除
1. SharedPointer< Tree<T> > remove(TreeNode<T>* node)

二叉樹中的結點刪除：

刪除操作功能的定義：

void remove(BTreeNode<T>* node, BTree<T>*& ret)
1. 將 node 為根結點的子樹從原來的二叉樹中刪除
2. ret 作為子樹返回 ( ret 指向堆空間中的二叉樹物件 )

刪除功能函式的實現：

在BTree.h中實現結點的刪除操作：

protected:
    virtual void remove(BTreeNode<T>* node, BTree<T>*& ret)
    {
        ret = new BTree<T>();

        if( ret == NULL )
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new tree ...");
        }
        else
        {
            if( root() == node )
            {
                this->m_root = NULL;
            }
            else
            {
                BTreeNode<T>* parent = dynamic_cast<BTreeNode<T>*>(node->parent);

                if( parent->left == node )
                {
                    parent->left = NULL;
                }
                else if( parent->right == node )
                {
                    parent->right = NULL;
                }

                node->parent = NULL;
            }

            ret->m_root = node;
        }
    }
public:
    SharedPointer< Tree<T> > remove(const T& value)
    {
        BTree<T>* ret = NULL;
        BTreeNode<T>* node = find(value);

        if( node == NULL )
        {
            THROW_EXCEPTION(InvalidParameterException, "Can not find the tree node via value ...");
        }
        else
        {
            remove(node, ret);
        }

        return ret;
    }

    SharedPointer< Tree<T> > remove(TreeNode<T>* node)
    {
        BTree<T>* ret = NULL;

        node = find(node);

        if( node == NULL )
        {
            THROW_EXCEPTION(InvalidParameterException, "Parameter node is invalid ...");
        }
        else
        {
            remove(dynamic_cast<BTreeNode<T>*>(node), ret);
        }

        return ret;
    }

mian.cpp測試：

#include <iostream>
#include "BTree.h"

using namespace std;
using namespace StLib;

int main()
{
    BTree<int> bt;
    BTreeNode<int>* n = NULL;

    bt.insert(1, NULL);

    n = bt.find(1);
    bt.insert(2, n);
    bt.insert(3, n);

    n = bt.find(2);
    bt.insert(4, n);
    bt.insert(5, n);

    n = bt.find(4);
    bt.insert(8, n);
    bt.insert(9, n);

    n = bt.find(5);
    bt.insert(10, n);

    n = bt.find(3);
    bt.insert(6, n);
    bt.insert(7, n);

    n = bt.find(6);
    bt.insert(11, n, LEFT);

    int a[] = {8, 9, 10, 11, 7};

    SharedPointer< Tree<int> > sp = bt.remove(3);

    for(int i=0; i<5; i++)
    {
        TreeNode<int>* node = sp->find(a[i]);

        while( node )
        {
            cout << node->value << " ";
            node = node->parent;
        }

        cout << endl;
    }

    return 0;
}

執行結果為：




11 6 3 
7 3

4.二叉樹中結點的清除操作

清除操作的定義：

void clear()
1. 將二叉樹中的所有結點清除 ( 釋放堆中的結點 )

二叉樹中結點的清除：

清除操作功能的定義：

free(node)
1. 清除 node 為根結點的二叉樹
2. 釋放二叉樹中的每一個結點

在BTree.h中實現結點的清除操作：

protected:
    virtual void free(BTreeNode<T>* node)
    {
        if( node != NULL )
        {
            free(node->left);
            free(node->right);

            if( node->flag() )
            {
                delete node;
            }
        }
    }
public:
    void clear()
    {
        free(root());

        this->m_root = NULL;
    }

5.小結

二叉樹的插入操作需要指明插入的位置
插入操作必須正確處理指向父結點的指標
插入資料元素時需要從堆空間中建立結點
當資料元素插入失敗時需要釋放結點空間

刪除操作將目標結點所代表的子樹移除
刪除操作必須完善處理父結點和子結點的關係
清除操作用於銷燬樹中的每個結點
銷燬結點時判斷是否釋放對應的記憶體空間 ( 工廠模式 )

最終的BTree.h程式碼：
BTree.h

#ifndef BTREE_H
#define BTREE_H

#include "Tree.h"
#include "BTreeNode.h"
#include "Exception.h"
#include "LinkQueue.h"

namespace StLib
{

template <typename T>
class BTree : public Tree<T>
{
protected:
    virtual BTreeNode<T>* find(BTreeNode<T>* node, const T& value) const
    {
        BTreeNode<T>* ret = NULL;

        if( node != NULL )
        {
            if( node->value == value )
            {
                return node;
            }
            else
            {
                if( ret == NULL )
                {
                    ret = find(node->left, value);
                }

                if( ret == NULL )
                {
                    ret = find(node->right, value);
                }
            }
        }

        return ret;
    }

    virtual BTreeNode<T>* find(BTreeNode<T>* node, BTreeNode<T>* obj) const
    {
        BTreeNode<T>* ret = NULL;

        if( node == obj )
        {
            return node;
        }
        else
        {
            if( node != NULL )
            {
                if( ret == NULL )
                {
                    ret = find(node->left, obj);
                }

                if( ret == NULL )
                {
                    ret = find(node->right, obj);
                }
            }
        }

        return ret;
    }

    virtual bool insert(BTreeNode<T>* n, BTreeNode<T>* np, BTNodePos pos)
    {
        bool ret = true;

        if( pos == ANY )
        {
            if( np->left == NULL )
            {
                np->left = n;
            }
            else if( np->right == NULL )
            {
                np->right = n;
            }
            else
            {
                ret = false;
            }
        }
        else if( pos == LEFT )
        {
            if( np->left == NULL )
            {
                np->left = n;
            }
            else
            {
                ret = false;
            }
        }
        else if( pos == RIGHT )
        {
            if( np->right == NULL )
            {
                np->right = n;
            }
            else
            {
                ret = false;
            }
        }
        else
        {
            ret = false;
        }

        return ret;
    }

    virtual void remove(BTreeNode<T>* node, BTree<T>*& ret)
    {
        ret = new BTree<T>();

        if( ret == NULL )
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new tree ...");
        }
        else
        {
            if( root() == node )
            {
                this->m_root = NULL;
            }
            else
            {
                BTreeNode<T>* parent = dynamic_cast<BTreeNode<T>*>(node->parent);

                if( parent->left == node )
                {
                    parent->left = NULL;
                }
                else if( parent->right == node )
                {
                    parent->right = NULL;
                }

                node->parent = NULL;
            }

            ret->m_root = node;
        }
    }

    virtual void free(BTreeNode<T>* node)
    {
        if( node != NULL )
        {
            free(node->left);
            free(node->right);

            if( node->flag() )
            {
                delete node;
            }
        }
    }
public:
    bool insert(TreeNode<T>* node)
    {
        return insert(node, ANY);
    }

    virtual bool insert(TreeNode<T>* node, BTNodePos pos)
    {
        bool ret = true;

        if( node != NULL )
        {
            if( this->m_root == NULL )
            {
                node->parent = NULL;
                this->m_root = node;
            }
            else
            {
                BTreeNode<T>* np = find(node->parent);

                if( np != NULL )
                {
                    ret = insert(dynamic_cast<BTreeNode<T>*>(node), np, pos);
                }
                else
                {
                    THROW_EXCEPTION(InvalidParameterException, "Invalid parent tree node ...");
                }
            }
        }
        else
        {
            THROW_EXCEPTION(InvalidParameterException, "Parameter node can not be NULL ...");
        }

        return ret;
    }

    bool insert(const T& value, TreeNode<T>* parent)
    {
        return insert(value, parent, ANY);
    }

    virtual bool insert(const T& value, TreeNode<T>* parent, BTNodePos pos)
    {
        bool ret = true;
        BTreeNode<T>* node = BTreeNode<T>::NewNode();

        if( node == NULL )
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new node ...");
        }
        else
        {
            node->value = value;
            node->parent = parent;

            ret = insert(node, pos);

            if( !ret )
            {
                delete node;
            }
        }

        return ret;
    }

    SharedPointer< Tree<T> > remove(const T& value)
    {
        BTree<T>* ret = NULL;
        BTreeNode<T>* node = find(value);

        if( node == NULL )
        {
            THROW_EXCEPTION(InvalidParameterException, "Can not find the tree node via value ...");
        }
        else
        {
            remove(node, ret);
        }

        return ret;
    }

    SharedPointer< Tree<T> > remove(TreeNode<T>* node)
    {
        BTree<T>* ret = NULL;

        node = find(node);

        if( node == NULL )
        {
            THROW_EXCEPTION(InvalidParameterException, "Parameter node is invalid ...");
        }
        else
        {
            remove(dynamic_cast<BTreeNode<T>*>(node), ret);
        }

        return ret;
    }

    BTreeNode<T>* find(const T& value) const
    {
        return find(root(), value);
    }

    BTreeNode<T>* find(TreeNode<T>* node) const
    {
        return find(root(), dynamic_cast<BTreeNode<T>*>(node));
    }

    BTreeNode<T>* root() const
    {
        return dynamic_cast<BTreeNode<T>*>(this->m_root);
    }

    int degree() const
    {
        return NULL;
    }

    int count() const
    {
        return NULL;
    }

    int height() const
    {
        return NULL;
    }

    void clear()
    {
        free(root());

        this->m_root = NULL;
    }

    ~BTree()
    {
        clear();
    }
};

}

#endif // BTREE_H

資料結構開發(23)：二叉樹中結點的查詢、插入、刪除與清除操作

0.目錄 1.二叉樹中結點的查詢操作 2.二叉樹中結點的插入操作 3.二叉樹中結點的刪除操作 4.二叉樹中結點的清除操作 5.小結 1.二叉樹中結點的查詢操作查詢的方式：基於資料元素值的查詢 BTreeNode<T>* find(const T&

資料結構開發(24)：二叉樹中屬性操作、層次遍歷與典型遍歷

0.目錄 1.二叉樹中屬性操作的實現 2.二叉樹結構的層次遍歷 3.二叉樹的典型遍歷方式 4.小結 1.二叉樹中屬性操作的實現二叉樹的屬性操作：二叉樹中結點的數目：定義功能：count(node) 在 node 為根結點的二叉樹中統計結點數目在

資料結構開發(25)：二叉樹中屬性操作、層次遍歷與典型遍歷

0.目錄 1.二叉樹的比較與相加 2.二叉樹的線索化實現 3.二叉樹的經典面試題分析 3.1 單度結點刪除 3.2 中序線索化二叉樹 4.小結 1.二叉樹的比較與相加二叉樹的克隆操作： SharedPointer< BTree<T> > clone

數據結構開發(22)：二叉樹的轉換、深層特性與存儲結構設計

his 9.png 二叉 klist efi remove ren binary 兩個 0.目錄 1.樹到二叉樹的轉換 2.二叉樹的深層特性 3.二叉樹的存儲結構設計 4.小結 1.樹到二叉樹的轉換通用樹結構的回顧：雙親孩子表示法每個結點都有一個指向其雙親的指針

資料結構和演算法：二叉樹

二叉樹二叉樹（Binary tree）是樹形結構的一個重要型別。許多實際問題抽象出來的資料結構往往是二叉樹形式，即使是一般的樹也能簡單地轉換為二叉樹，而且二叉樹的儲存結構及其演算法都較為簡單，因此二叉樹顯得特別重要。二叉樹特點是每個節點最多隻能有兩棵子樹，即樹的度最大為2，且有左右之分。二叉樹是n個有限

資料結構筆記：二叉樹中屬性操作的實現

二叉樹的屬性操作 count() = 10; height() = 4; degree() = 2; 二叉樹結點的數目 -定義功能：count(node) ·在node為根結點的二叉樹中統計結點數目 int count(BTreeNode<T>* nod

資料結構筆記：二叉樹中的結點刪除與清除

刪除的方式 -基於資料元素值的刪除 ·SharedPointer<Tree<T>>remove(const T& value) -基於結點的刪除 ·SharedPointer<Tree <T>>remove(TreeNode&l

資料結構筆記：二叉樹中的結點插入操作

是否能夠在二叉樹的而已結點出插入子結點？ -不能，二叉樹結點的每個結點的子結點是固定的，只存在左孩子和右孩子. 是否需要指定新資料元素（新結點）的插入位置？ -需要指定為左孩子或者右孩子 enum BTNodePos { ANY, LEFT, RIGHT };

資料結構筆記：二叉樹中的結點查詢操作

查詢的方式 -基於資料元素值的查詢 ·BTreeNode<T>* find(const T& value) const -基於結點的查詢 ·BTreeNode<T>* find(TreeNode<T>* node) const 基於資料

【資料結構】BST：二叉排序樹演算法

基本數據結構學習總結：二叉樹的遍歷

root 取出後序二叉 isnull 就是 bre 遞歸 use 二叉搜索樹的遍歷二叉樹遍歷的內容很多，但是也是最重要的，最需要理解的，很多二叉樹的相關算法，只要用活了遍歷就沒有問題了前序遍歷對於每一棵樹，先遍歷其根節點，然後遍歷其左子樹，最後用同樣的方式遍歷

資料結構——4.2 平衡二叉樹

搜尋樹結點不同的插入次序，將導致不同的深度和平均查詢長度ASL 平衡因子：BF（T）=hL-hR，其中hL和hR分別為T的左右子樹的高度。平衡二叉樹（AVL樹）：是一個空樹或者要求任一結點左右子樹高度差的絕對值小於等於1，即|BF(T)| <=1 設nh為高度是h

資料結構之－平衡二叉樹(AVL)

背景不同結構的二叉查詢樹，查詢效率有很大的不同。如何解決這個問題呢？關鍵在於如何最大限度的減小樹的深度。正是基於這個想法，平衡二叉樹出現了。前言平衡二叉搜尋樹（英語：Balanced Binary Tree）是一種結構平衡的二叉搜尋樹。它能在O(log n)時間內完成插入、查詢和

【資料結構】3-1 二叉樹的先序建立及遍歷操作

二叉樹真的令人頭大 #include<iostream> using namespace std; template <class T> struct BTNode//二叉連結串列結點結構 { T data; //二叉樹中的元素 BTNode<T>

資料結構——鏈佇列實現二叉樹的層次遍歷

在二叉樹的遍歷這篇部落格中https://www.cnblogs.com/wkfvawl/p/9901462.html 對於二叉樹的層次遍歷我只是給出了基於C++ STL的程式碼，這裡我使用資料結構的連結串列，構建一個鏈佇列來實現。這也算是我第一次使用鏈佇列來完成某個任務，鏈佇列程式碼還是來自課本，因為之前

資料結構實驗-C語言-二叉樹的建立，前、中、後序遍歷的遞迴演算法和非遞迴演算法，求葉子結點數目，求二叉樹深度，判斷二叉樹是否相似，求二叉樹左右子樹互換，二叉樹層序遍歷的演算法，判斷二叉樹是否是完全二叉樹

1.實驗目的熟練掌握二叉樹的二叉連結串列儲存結構的C語言實現。掌握二叉樹的基本操作-前序、中序、後序遍歷二叉樹的三種方法。瞭解非遞迴遍歷過程中“棧”的作用和狀態，而且能靈活運用遍歷演算法實現二叉樹的其它操作。 2.實驗內容（1）二叉樹的二叉連結串列的建立（2）二叉樹的前、中、後

C語言複習資料結構之簡單的二叉樹輸入和輸出操作

C語言複習之簡單的二叉樹的僅輸入輸出操作 1：結構體 typedef struct TreeNode{ _Data value; struct TreeNode * father; struct TreeNode * right; stru

【資料結構學習筆記】二叉樹和其他樹

基礎定義一個樹t是一個非空的有限元素的集合，其中一個元素為根（root），其餘的元素（如果有的話）組成t的子樹（subtree）樹的另一常用術語為級（level）。樹根是1級，其孩子（如果有）是2級，孩子的孩子是3級，等等。一棵樹的高度（height）或深度（de

【資料結構】給定一個二叉樹，檢查它是否是映象對稱的

給定一個二叉樹，檢查它是否是映象對稱的。例如，二叉樹 [1,2,2,3,4,4,3] 是對稱的。 1 / \ 2 2 / \ / \ 3 4 4 3 但是下面這個 [1,2,2,null,3,null,3]則不是映象對稱的: 1

資料結構（四）二叉樹的遍歷

二叉樹的遍歷 0. 樹的表示 typedef struct TreeNode *BinTree; struct TreeNode{ int Data; // 存值 BinTree Left; // 左兒子結點 BinTree Right;

資料結構開發(23)：二叉樹中結點的查詢、插入、刪除與清除操作

0.目錄

1.二叉樹中結點的查詢操作

2.二叉樹中結點的插入操作

3.二叉樹中結點的刪除操作

4.二叉樹中結點的清除操作

5.小結

1.二叉樹中結點的查詢操作

2.二叉樹中結點的插入操作

3.二叉樹中結點的刪除操作

4.二叉樹中結點的清除操作

5.小結

相關推薦