資料結構開發(21)：樹中屬性操作與層次遍歷

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

0.目錄

1.樹中屬性操作的實現

2.樹形結構的層次遍歷

3.小結

1.樹中屬性操作的實現

樹中結點的數目：

定義功能：count(node)
1. 在 node 為根結點的樹中統計結點數目

樹結點數目的計算示例：

count(A) = count(B) + count(C) + count(D) + 1

在GTree.h中實現統計結點數目：

protected:
    int count(GTreeNode<T>* node) const
    {
        int ret = 0;

        if( node != NULL )
        {
            ret = 1;

            for(node->child.move(0); !node->child.end(); node->child.next())
            {
                ret += count(node->child.current());
            }
        }

        return ret;
    }
public:
    int count() const
    {
        return count(root());
    }

樹的高度：

定義功能：height(node)
1. 獲取 node 為根結點的樹的高度

樹的高度計算示例：

height(A) = MAX{ height(B), height(C), height(D) } + 1

在GTree.h中實現獲取樹的高度：

protected:
    int height(GTreeNode<T>* node) const
    {
        int ret = 0;

        if( node != NULL )
        {
            for(node->child.move(0); !node->child.end(); node->child.next())
            {
                int h = height(node->child.current());

                if( ret < h )
                {
                    ret = h;
                }
            }

            ret = ret + 1;
        }

        return ret;
    }
public:
    int height() const
    {
        return height(root());
    }

樹的度數：

定義功能：degree(node)
1. 獲取 node 為根結點的樹的度數

樹的度計算示例：

degree(A) = MAX{ degree(B), degree(C), degree(D), 3 }

在GTree.h中實現獲取樹的度數：

protected:
    int degree(GTreeNode<T>* node) const
    {
        int ret = 0;

        if( node != NULL )
        {
            ret = node->child.length();

            for(node->child.move(0); !node->child.end(); node->child.next())
            {
                int d = degree(node->child.current());

                if( ret < d )
                {
                    ret = d;
                }
            }
        }

        return ret;
    }
public:
    int degree() const
    {
        return degree(root());
    }

統一mian.cpp測試：

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

using namespace std;
using namespace StLib;

int main()
{
    GTree<char> t;
    GTreeNode<char>* node = NULL;
    GTreeNode<char> root;

    root.value = 'A';
    root.parent = NULL;

    t.insert(&root);

    node = t.find('A');
    t.insert('B', node);
    t.insert('C', node);
    t.insert('D', node);

    node = t.find('B');
    t.insert('E', node);
    t.insert('F', node);

    node = t.find('E');
    t.insert('K', node);
    t.insert('L', node);

    node = t.find('C');
    t.insert('G', node);

    node = t.find('D');
    t.insert('H', node);
    t.insert('I', node);
    t.insert('J', node);

    node = t.find('H');
    t.insert('M', node);

    cout << t.count() << endl;
    cout << t.height() << endl;
    cout << t.degree() << endl;

    return 0;
}

執行結果為：

13
4
3

2.樹形結構的層次遍歷

問題：

如何按層次遍歷通用樹結構中的每一個數據元素？

當前的事實：

樹是非線性的資料結構，樹的結點沒有固定的編號方式

新的需求：

為通用樹結構提供新的方法，快速遍歷每一個結點

設計思路(遊標)：

在樹中定義一個遊標 ( GTreeNode
遍歷開始前將遊標指向根結點 ( root() )
獲取遊標指向的資料元素
通過結點中的 child 成員移動遊標

提供一組遍歷相關的函式，按層次訪問樹中的資料元素。

層次遍歷演算法：

原料：class LinkQueue<T>;
遊標：LinkQueue<T>: :front();
思想：
1. begin() → 將根結點壓入佇列中
2. current() → 訪問隊頭元素指向的資料元素
3. next() → 隊頭元素彈出，將隊頭元素的孩子壓入佇列中 ( 核心 )
4. end() → 判斷佇列是否為空

層次遍歷演算法示例：

在GTree.h中實現樹形結構的層次遍歷：

protected:
    LinkQueue<GTreeNode<T>*> m_queue;
public:
    bool begin()
    {
        bool ret = (root() != NULL);

        if( ret )
        {
            m_queue.clear();
            m_queue.add(root());
        }

        return ret;
    }

    bool end()
    {
        return (m_queue.length() == 0);
    }

    bool next()
    {
        bool ret = (m_queue.length() > 0);

        if( ret )
        {
            GTreeNode<T>* node = m_queue.front();

            m_queue.remove();

            for(node->child.move(0); !node->child.end(); node->child.next())
            {
                m_queue.add(node->child.current());
            }
        }

        return ret;
    }

    T current()
    {
        if( !end() )
        {
            return m_queue.front()->value;
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No value at current position ...");
        }
    }

然後在其他地方加入對應的清空佇列的程式碼：

public:
    SharedPointer< Tree<T> > remove(const T& value)
    {
        GTree<T>* ret = NULL;
        GTreeNode<T>* node = find(value);

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

            m_queue.clear();
        }

        return ret;
    }

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

        node = find(node);

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

            m_queue.clear();
        }

        return ret;
    }

最後把GTree和GTreeNode類的拷貝構造和賦值操作都宣告為保護成員函式：
GTree.h

protected:
    GTree(const GTree<T>&);
    GTree<T>& operator = (const GTree<T>&);
public:
    GTree()
    {

    }

GTreeNode.h

protected:
    GTreeNode(const GTreeNode<T>&);
    GTreeNode<T>& operator = (const GTreeNode<T>&);

最終main.cpp測試

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

using namespace std;
using namespace StLib;

int main()
{
    GTree<char> t;
    GTreeNode<char>* node = NULL;
    GTreeNode<char> root;

    root.value = 'A';
    root.parent = NULL;

    t.insert(&root);

    node = t.find('A');
    t.insert('B', node);
    t.insert('C', node);
    t.insert('D', node);

    node = t.find('B');
    t.insert('E', node);
    t.insert('F', node);

    node = t.find('E');
    t.insert('K', node);
    t.insert('L', node);

    node = t.find('C');
    t.insert('G', node);

    node = t.find('D');
    t.insert('H', node);
    t.insert('I', node);
    t.insert('J', node);

    node = t.find('H');
    t.insert('M', node);

    for(t.begin(); !t.end(); t.next())
    {
        cout << t.current();
    }
    cout << endl;

    return 0;
}

執行結果為：

ABCDEFGHIJKLM

3.小結

樹的結點沒有固定的編號方式
可以按照層次關係對樹中的結點進行遍歷
通過遊標的思想設計遍歷成員函式
遍歷成員函式是相互依賴，相互配合的關係
遍歷演算法的核心為佇列的使用

最終的GTree.h程式碼：

#ifndef GTREE_H
#define GTREE_H

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

namespace StLib
{

template <typename T>
class GTree : public Tree<T>
{
protected:
    LinkQueue<GTreeNode<T>*> m_queue;

    GTree(const GTree<T>&);
    GTree<T>& operator = (const GTree<T>&);

    GTreeNode<T>* find(GTreeNode<T>* node, const T& value) const
    {
        GTreeNode<T>* ret = NULL;

        if( node != NULL )
        {
            if( node->value == value )
            {
                return node;
            }
            else
            {
                for(node->child.move(0); !node->child.end() && (ret == NULL); node->child.next())
                {
                    ret = find(node->child.current(), value);
                }
            }
        }

        return ret;
    }

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

        if( node == obj )
        {
            return node;
        }
        else
        {
            if( node != NULL )
            {
                for(node->child.move(0); !node->child.end() && (ret == NULL); node->child.next())
                {
                    ret = find(node->child.current(), obj);
                }
            }
        }

        return ret;
    }

    void free(GTreeNode<T>* node)
    {
        if( node != NULL )
        {
            for(node->child.move(0); !node->child.end(); node->child.next())
            {
                free(node->child.current());
            }

            if( node->flag() )
            {
                delete node;
            }
        }
    }

    void remove(GTreeNode<T>* node, GTree<T>*& ret)
    {
        ret = new GTree<T>();

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

                child.remove(child.find(node));

                node->parent = NULL;
            }

            ret->m_root = node;
        }
    }

    int count(GTreeNode<T>* node) const
    {
        int ret = 0;

        if( node != NULL )
        {
            ret = 1;

            for(node->child.move(0); !node->child.end(); node->child.next())
            {
                ret += count(node->child.current());
            }
        }

        return ret;
    }

    int height(GTreeNode<T>* node) const
    {
        int ret = 0;

        if( node != NULL )
        {
            for(node->child.move(0); !node->child.end(); node->child.next())
            {
                int h = height(node->child.current());

                if( ret < h )
                {
                    ret = h;
                }
            }

            ret = ret + 1;
        }

        return ret;
    }

    int degree(GTreeNode<T>* node) const
    {
        int ret = 0;

        if( node != NULL )
        {
            ret = node->child.length();

            for(node->child.move(0); !node->child.end(); node->child.next())
            {
                int d = degree(node->child.current());

                if( ret < d )
                {
                    ret = d;
                }
            }
        }

        return ret;
    }
public:
    GTree()
    {

    }

    bool insert(TreeNode<T>* node)
    {
        bool ret = true;

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

                if( np != NULL )
                {
                    GTreeNode<T>* n = dynamic_cast<GTreeNode<T>*>(node);

                    if( np->child.find(n) < 0 )
                    {
                        np->child.insert(n);
                    }
                }
                else
                {
                    THROW_EXCEPTION(InvalidOperationException, "Invalid parent tree node ...");
                }
            }
        }
        else
        {
            THROW_EXCEPTION(InvalidParameterException, "Parameter node cannot be NULL ...");
        }

        return ret;
    }

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

        if( node != NULL )
        {
            node->value = value;
            node->parent = parent;

            insert(node);
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create new tree node ...");
        }

        return ret;
    }

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

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

            m_queue.clear();
        }

        return ret;
    }

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

        node = find(node);

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

            m_queue.clear();
        }

        return ret;
    }

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

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

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

    int degree() const
    {
        return degree(root());
    }

    int count() const
    {
        return count(root());
    }

    int height() const
    {
        return height(root());
    }

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

        this->m_root = NULL;

        m_queue.clear();
    }

    bool begin()
    {
        bool ret = (root() != NULL);

        if( ret )
        {
            m_queue.clear();
            m_queue.add(root());
        }

        return ret;
    }

    bool end()
    {
        return (m_queue.length() == 0);
    }

    bool next()
    {
        bool ret = (m_queue.length() > 0);

        if( ret )
        {
            GTreeNode<T>* node = m_queue.front();

            m_queue.remove();

            for(node->child.move(0); !node->child.end(); node->child.next())
            {
                m_queue.add(node->child.current());
            }
        }

        return ret;
    }

    T current()
    {
        if( !end() )
        {
            return m_queue.front()->value;
        }
        else
        {
            THROW_EXCEPTION(InvalidOperationException, "No value at current position ...");
        }
    }

    ~GTree()
    {
        clear();
    }
};

}

#endif // GTREE_H

資料結構開發(21)：樹中屬性操作與層次遍歷

0.目錄 1.樹中屬性操作的實現 2.樹形結構的層次遍歷 3.小結 1.樹中屬性操作的實現樹中結點的數目：定義功能：count(node) 在 node 為根結點的樹中統計結點數目樹結點數目的計算示例： count(A) = count(B)

數據結構開發(21)：樹中屬性操作與層次遍歷

思路 img emp 遍歷 ios 需求 next() abcd reat 0.目錄 1.樹中屬性操作的實現 2.樹形結構的層次遍歷 3.小結 1.樹中屬性操作的實現樹中結點的數目：定義功能：count(node) 在 node 為根結點的樹中統計結點數目樹

資料結構開發(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

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

樹中結點的數目 -定義功能：count(node) ·在node為根結點的樹中統計結點的數目 int count(GTreeNode<T>* node) const { int ret = 0; if(node != NULL)

資料結構開發(15)：遞迴的思想與應用

0.目錄 1.遞迴的思想 2.遞迴的應用 2.1 單向連結串列的轉置 2.2 單向排序連結串列的合併 2.3 漢諾塔問題 2.4 全排列問題 2.5 逆序列印單鏈表中的偶數結點 2.6 八皇后問題 3.小結 1.遞迴的思想遞迴是一種數學上分而自治的思想：將

C++資料結構之 --二叉樹簡單實現和4種遍歷

實驗目的：實現簡單的二叉樹！標頭檔案：二叉樹.h #ifndef 二叉樹_h__ #define 二叉樹_h__ #include <iostream> #include <q

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

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

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

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

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

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

資料結構篇：二叉樹（三：根據中序和後序遍歷結果推算出完整二叉樹）

我們先理解一下前中後序遍歷，這是基礎。 //前序遍歷 void Tree::PreOrderTraverse(BiTree *T) { if(!T) { return ; } else { cout<<T->data<<" "; PreOrder

資料結構開發(1)：學習前的準備（上）

0.目錄 1.泛型程式設計簡介 2.智慧指標示例 3.異常類構建 3.1 C++異常簡介 3.2 異常類構建 4.小結參考前文傳送門： C++解析(26)：函式模板與類模板 C++解析(20)：智慧指標與型別轉換函式 C++解析(28)：異常處理 1.泛型程式設計簡介資料結構

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

#include <iostream> #define NULL 0 using namespace std; template<class T> struct BTNode { T data; BTNode<T> *lChild, *rC

資料結構開發(8)：再論智慧指標

0.目錄 1.Pointer與SmartPointer 2.SharedPointer 3.小結 1.Pointer與SmartPointer 本節目標：完成 Pointer 類的具體實現完成 SmartPointer 類的具體實現思考使用智慧指標( SmartPo

資料結構開發(9)：迴圈連結串列與雙向連結串列

0.目錄 1.迴圈連結串列的實現 2.雙向連結串列的實現 3.小結 1.迴圈連結串列的實現什麼是迴圈連結串列? 概念上任意資料元素都有一個前驅和一個後繼所有的資料元素的關係構成一個邏輯上的環實現上迴圈連結串列是一種特殊的單鏈表

資料結構開發(11)：雙向迴圈連結串列的實現

0.目錄 1.雙向迴圈連結串列的實現 2.小結 1.雙向迴圈連結串列的實現本節目標：使用 Linux 核心連結串列實現 StLib 中的雙向迴圈連結串列 template <typename T> class DualCircleList; StLib 中雙向迴圈

資料結構開發(14)：KMP 子串查詢演算法

0.目錄 1.KMP 子串查詢演算法 2.KMP 演算法的應用 3.小結 1.KMP 子串查詢演算法問題：如何在目標字串S中，查詢是否存在子串P？樸素解法：樸素解法的一個優化線索：示例：偉大的發現：匹配失敗時的右移位數與子串本身相關，與目標串無關移動位數 =

資料結構開發(16)：選擇排序和插入排序

0.目錄 1.排序的基本概念 2.選擇排序 3.插入排序 4.小結 1.排序的基本概念排序的一般定義：排序是計算機內經常進行的一種操作，其目的是將一組“無序”的資料元素調整為“有序”的資料元素。排序的數學定義：排序的示例：問題：按總評排序後為什麼張無忌

【資料結構】二叉樹的前中後遍歷與層次遍歷(遞迴與非遞迴)

水一波作業 #include <iostream> #include <cstring> //#pragma GCC optimize(2) #include<time.h> #include <map> #include &

【資料結構】二叉樹中任意兩節點的最近公共祖先節點

問題要求：任意給出二叉樹中的兩個節點，求他們的最近祖先分三種情況： 1、該二叉樹是搜尋二叉樹如果兩個節點的值都大於根節點，則遍歷右子樹查詢一個處於兩節點之間的值為最近祖先，如果兩個節點的值都小於根節點，則遍歷左子樹查詢一個兩節點之間的值為最近祖先插入程式碼 Node*

資料結構開發(21)：樹中屬性操作與層次遍歷

0.目錄

1.樹中屬性操作的實現

2.樹形結構的層次遍歷

3.小結

1.樹中屬性操作的實現

2.樹形結構的層次遍歷

3.小結

相關推薦