【数据结构】广义表的默认成员函数、深度、大小、打印

原创 2016年05月30日 17:18:37

广义表的定义:

广义表是非线性的结构,是n个元素的有限序列。

wKiom1cTUC7RB4CcAAAw4q17T88241.png

举例:A=(a,b,(c,d))


我们先定义它的结构:

(1)它有三种节点,头节点、值节点、子表节点。

(2)两种指向下一节点的指针:指向下一值值节点的指针_next,指向子表节点的指针_sublink.


enum Type//用枚举形式来定义广义表中三种节点类型
{
    HEAD, //头类型
    VALUE,//值类型
    SUB,//子表类型
};

struct GeneralizedNode
{
    Type _type;//类型
    GeneralizedNode* _next;//指向下一节点的指针
    union
    {
        int _value;//一个节点下一节点可能是值节点,也可能是子表节点
        GeneralizedNode* _sublink;
    }; 

    GeneralizedNode(Type type)
        :_next(NULL)
        , _type(type)
    {}
    
    GeneralizedNode(Type type,int value)
        :_next(NULL)
        , _type(type)
        , _value(value)
        {}
};


下面,我们来看下实现的代码:

class Generalized
{
public:
    Generalized()
        :_head(NULL)
    {}

    Generalized(const char* str)
    {
        _head = _CreateList(str);//调用函数创建节点
    }

    Generalized(const Generalized& gr)
    {
        _head = _Copy(gr._head);//调用函数拷贝节点
    }

    Generalized& operator=(const Generalized& gr)
    {
        if (&gr != this)
        {
            _Copy(gr._head);
            _Destroy(_head);
        }
        return *this;
    }

    ~Generalized()
    {
        _Destroy(_head);
    }

    void Print()
    {
        _Print(_head);
    }

    size_t Size()
    {
        return _Size(_head);
    }

    size_t Depth()
    {
        return _Depth(_head);
    }

protected:
    //拷贝广义表
    GeneralizedNode* _Copy(GeneralizedNode* grhead)
    {
        GeneralizedNode* grcur = grhead;

        GeneralizedNode* newHead = new GeneralizedNode(HEAD);
        GeneralizedNode* newcur = newHead;

        while (grcur)
        {
            if (grcur->_type == VALUE)
            {
                GeneralizedNode* tmp = new GeneralizedNode(VALUE);
                newcur->_next = tmp;
                newcur = newcur->_next;
                newcur->_value = grcur->_value;
            }
            
            else if (grcur->_type == SUB)
            {
                GeneralizedNode* tmp = new GeneralizedNode(SUB);
                newcur->_next = tmp;
                newcur = newcur->_next;
                newcur->_sublink = _Copy(grcur->_sublink);
            }
            grcur = grcur->_next;
        }
        newcur = NULL;
        return newHead;
    }

    //释放广义表
    void _Destroy(GeneralizedNode* head)
    {
        GeneralizedNode* cur = head;
        while (cur)
        {
            GeneralizedNode* del = cur;
            cur = cur->_next;
            if (del->_type == SUB)
            {
                _Destroy(del->_sublink);
            }
            else
            {
                delete del;
                del = NULL;
            }
        }
    }

    //打印
    void _Print(GeneralizedNode* head)
    {    
        GeneralizedNode* cur = head;
        while (cur)
        {
            if (cur->_type == HEAD)
            {
                cout << "(";
            }
            else if (cur->_type == VALUE)
            {
                cout << (char)(cur->_value);
                if (cur->_next)
                {
                    cout << ",";
                }
            }
            else if (cur->_type == SUB)
            {
                _Print(cur->_sublink);
                if (cur->_next)
                {
                    cout << ",";
                }
            }
            cur = cur->_next;
        }
        cout << ")";        
    }

    //判断是否是值
    bool _IsValue(const char* str)
    {
        if (*str > 0 && *str<9
            || *str>'a' && *str<'z'
            || *str>'A' && *str < 'Z')
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    //创建节点
    GeneralizedNode* _CreateList(const char* str)
    {
        assert(*str=='(');
        ++str;
        GeneralizedNode* head = new GeneralizedNode(HEAD);
        GeneralizedNode* cur = head;
        while (cur)
        {
            if (_IsValue(str))
            {
                 cur->_next = new GeneralizedNode(VALUE,*str);
                cur = cur->_next;
                str++;
            }
            else if (*str == '(')
            {
                GeneralizedNode* SubNode = new GeneralizedNode(SUB);
                cur->_next = SubNode;
                cur = cur->_next;
                SubNode->_sublink = _CreateList(str);
                str++;
            }
            else if (*str == ')')
            {
                str++;
                return head;
            }
            else
            {
                str++;
            }
        }
        cout << "广义表出错!" << endl;
        assert(false);
        return head;
    }

    //大小(值节点数)
    size_t _Size(GeneralizedNode* head)
    {
        GeneralizedNode* cur = head;
        size_t size = 0;
        while (cur)
        {
            if (cur->_type == VALUE)
            {
                size++;
            }
            else if (cur->_type == SUB)
            {
                size += _Size(cur->_sublink);
            }
            cur = cur->_next;
        }
        return size;
    }

    //深度
    size_t _Depth(GeneralizedNode* head)
    {
        size_t depth = 1;
        GeneralizedNode* cur = head;
        while (cur)
        {
            if (cur->_type == SUB)
            {
                size_t curdepth = _Depth(cur->_sublink);
    
                if (curdepth + 1 > depth)
                {
                    depth = curdepth + 1;
                }
            }
            cur = cur->_next;
        }
        return depth;
    }

private:
    GeneralizedNode* _head;
};

void Test()
{
    Generalized gr1("()");
    Generalized gr2("(a,b,(c,d))");
    Generalized gr3("(a,b,(c,(d),e))");
    Generalized gr4(gr3);
    gr1.Print();
    cout << endl;
    gr2.Print();
    cout << endl;

    gr3.Print();
    cout << endl;

    gr4.Print();
    cout << endl;

    size_t size = gr4.Size();
    cout << "gr4大小:"<<size << endl;
    int depth = gr4.Depth();
    cout << "gr4深度:" << depth << endl;
}

int main()
{
    Test();
    system("pause");
    return 0;
}


本文出自 “Han Jing's Blog” 博客,请务必保留此出处http://10740184.blog.51cto.com/10730184/1764567

数据结构C语言实现系列[9]——广义表

#include stdio.h>#include stdlib.h>typedef char elemType; /*****************************************...
  • DL88250
  • DL88250
  • 2007年01月29日 01:36
  • 3119

广义表的长度和深度

广义表LS=(f,(),(e),(a,(b,c,d)))的长度是多少,深度是多少 例如上表、长度为4、深度为3、为什么呢 长度的求法为最大括号中的逗号数加一、LS最大括号内有 1. f 元素后边...
  • zhangkongzhongyun
  • zhangkongzhongyun
  • 2014年03月24日 14:40
  • 21233

广义表操作 (Java实现)——广义表深度、广义表长度、打印广义表信息

广义表是对线性表的扩展——线性表存储的所有的数据都是原子的(一个数或者不可分割的结构),且所有的数据类型相同。而广义表是允许线性表容纳自身结构的数据结构。 广义表定义:       广义表是由n个元素...
  • sun_star1chen
  • sun_star1chen
  • 2014年01月06日 09:03
  • 2129

广义表的长度和广义表的深度

广义表的长度和广义表的深度 广义表是对线性表的扩展——线性表存储的所有的数据都是原子的(一个数或者不可分割的结构),且所有的数据类型相同。而广义表是允许线性表容纳自身结构的数据结构。 广义...
  • zhupengqq
  • zhupengqq
  • 2016年07月08日 09:32
  • 5544

广义表的长度和深度计算

广义表(a,(a,b),d,e,((i,j),k))的长度是( ),深度是( ) 其长度为5、深度为3、为什么呢? 长度的求法为最大括号中的逗号数加1, 即为: a后面的逗号, (a,b)后...
  • W_K_L
  • W_K_L
  • 2018年01月05日 18:05
  • 123

广义表求深度

描述 按表头、表尾的分析方法重写求广义表深度的递归算法   输入 输入一串以'('开始,以')'结束的字符串,并且输入的左右括号必须匹配,如:(),(())..   输出 分别输出按表头...
  • axiqia
  • axiqia
  • 2016年03月25日 19:14
  • 2549

广义表的基本操作实现

广义表的四个特征:(1)广义线性表;(2)元素复合性;(3)元素递归性;(4)元素共享性     广义表的上述四个特征对于他的使用价值和应用效果起到了很大的作用。广义表的结构相当灵活,它可以兼容线性...
  • qq_28598203
  • qq_28598203
  • 2016年04月21日 19:19
  • 4005

学习笔记(4)——数组和广义表

此处介绍的数组不是C、C++等语言中定义的数组,注意区别。 n维数组,每维含有mi个数据(i=1,2,...,n),则n维数组含有sum(mi)个数据。其中,n称为数组的维数,mi称为维界。数组一旦...
  • lxy869735855
  • lxy869735855
  • 2015年12月10日 10:51
  • 384

数据结构学习笔记之广义表的相关知识点

广义表(Lists,又称列表)是一种非线性的数据结构,是线性表的一种推广,广泛的应用于人工智能等领域的表处理语言LISP语言中,因此,掌握对广义表的基础的CRUD操作很是重要...
  • qq_24754061
  • qq_24754061
  • 2016年06月04日 00:19
  • 1421

广义表求长度和深度C++

C++构建一张广义表,求其长度和深度。
  • J_Anson
  • J_Anson
  • 2015年11月06日 00:43
  • 1142
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【数据结构】广义表的默认成员函数、深度、大小、打印
举报原因:
原因补充:

(最多只允许输入30个字)