数据结构开发(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

原文地址：https://www.cnblogs.com/PyLearn/p/10159218.html

时间： 2024-10-09 11:33:29

数据结构开发(21)：树中属性操作与层次遍历的相关文章

数据结构开发(24)：二叉树中属性操作、层次遍历与典型遍历

0.目录 1.二叉树中属性操作的实现 2.二叉树结构的层次遍历 3.二叉树的典型遍历方式 4.小结 1.二叉树中属性操作的实现 二叉树的属性操作: 二叉树中结点的数目: 定义功能:count(node) 在 node 为根结点的二叉树中统计结点数目 在BTree.h中实现统计结点数目: protected: int count(BTreeNode<T>* node) const { int ret = 0; if( node != NULL ) { ret = count(node->l

数据结构开发(25)：二叉树中属性操作、层次遍历与典型遍历

0.目录 1.二叉树的比较与相加 2.二叉树的线索化实现 3.二叉树的经典面试题分析 3.1 单度结点删除 3.2 中序线索化二叉树 4.小结 1.二叉树的比较与相加 二叉树的克隆操作: SharedPointer< BTree<T> > clone() const 克隆当前树的一份拷贝 返回值为堆空间中的一棵新二叉树 ( 与当前树相等 ) 二叉树的克隆: 定义功能:clone(node) 拷贝 node 为根结点的二叉树 ( 数据元素在对应位置相等 ) 在BTree.h中实现二叉

树——通用树中属性操作的实现

1,树中的属性操作有: 1,树中结点的数目,树中高度,树的度数: 2,树中结点数目: 1,定义功能:count(node) 1,在 node 为根结点的树中统计结点数目: 2,递归实现: 2,功能函数代码实现: 1 /* 求以 node 为根结点所代表的树的结点数目,实现的很精妙 */ 2 int count(GTreeNode<T>* node) const // 公有的 count() 函数为 const 函数 3 { 4 int ret = 0; 5 6 if( node != NULL

第五十七课 树中属性操作的实现

添加count函数: 1 #ifndef GTREE_H 2 #define GTREE_H 3 4 #include "Tree.h" 5 #include "GTreeNode.h" 6 #include "Exception.h" 7 8 namespace DTLib 9 { 10 11 template < typename T > 12 class GTree : public Tree<T> 13 { 14

数据结构上机测试2-1:单链表操作A (顺序建表+关键字删除)

数据结构上机测试2-1:单链表操作A Time Limit: 1000MS Memory limit: 4096K 题目描述 输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,将单链表中的值为m的结点全部删除.分别输出建立的初始单链表和完成删除后的单链表. 输入 第一行输入数据个数n: 第二行依次输入n个整数: 第三行输入欲删除数据m. 输出 第一行输出原始单链表的长度: 第二行依次输出原始单链表的数据: 第三行输出完成删除后的单链表长度: 第四行依次输出完成删除后的

让你提前认识软件开发(21)：C程序中的定时器

第1部分 重新认识C语言 C程序中的定时器 [文章摘要] 在实际的C程序中,一个模块执行多个操作是很常见的事情.如果多个操作同时进行,会出现程序效率低下.计算机CPU占用率过高等情况,这时就需要对所有操作的执行顺序作一个合理的安排,这就涉及到定时器的使用. 本文对C程序中的定时器的类型.设置和清除方法等作了详细的介绍,为相关开发工作的开展提供了参考. [关键词] C程序  定时器  操作  开发 一.定时器的定义及分类 我们所熟悉的定时器是一个多任务定时提醒的软件,安装于电脑或手机上.举个例子,

【嵌入式开发】裸机引导操作系统和ARM 内存操作 ( DRAM SRAM 类型 简介 | Logical Bank | 内存地址空间介绍 | 内存芯片连接方式 | 内存初始化 | 汇编代码示例 )

[嵌入式开发]ARM 内存操作 ( DRAM SRAM 类型 简介 | Logical Bank | 内存地址空间介绍 | 内存芯片连接方式 | 内存初始化 | 汇编代码示例 ) 一. 内存 简介 1. 两大内存分类 ( 1 ) DRAM 简介 ( 定期刷新 | 速度慢 | 成本低 ) DRAM 简介 : 1.硬件描述 : DRAM 基本由一个个小电容基本原件组成, 电容的两端保留电荷; 2.优缺点描述 : ① 优点 : 成本很低, 很便宜; ② 缺点 : 需要 定期刷新数据, 速度较慢; a.

二叉树各种相关操作(建立二叉树、前序、中序、后序、求二叉树的深度、查找二叉树节点，层次遍历二叉树等）（C语言版)

将二叉树相关的操作集中在一个实例里,有助于理解有关二叉树的相关操作: 1.定义树的结构体: 1 typedef struct TreeNode{ 2 int data; 3 struct TreeNode *left; 4 struct TreeNode *right; 5 }TreeNode; 2.创建根节点: 1 TreeNode *creatRoot(){ 2 TreeNode * root =(TreeNode *)malloc(sizeof(TreeNode)); 3 if(NULL=

T-SQL开发 - 10.IDENTITY属性使用小结

从SQL Server 2012开始有了Sequence,简单用列如下: CREATE SEQUENCE TestSeq START WITH 1 INCREMENT BY 1; SELECT NEXT VALUE FOR TestSeq AS NextValue; 在这之前,表中生成序列号大多都是借助IDENTITY列属性,当然也有一些时候,是在自定义表中,自己维护序列号. 一. 创建IDENTITY列 if OBJECT_ID('test','U') is not null     drop