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

原创 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

相关文章推荐

【数据结构】堆的实现(包括:默认成员函数,插元素push,删元素pop,访问根节点top,判空,大小)

在数据结构里,堆是一类很重要的结构。堆结构是一组数组对象,我们可以把它当作是一颗完全二叉树。最大堆:堆里每一个父亲节点大于它的子女节点。最小堆:堆里每一个父亲节点小于它的子女节点。如图就是一个最大堆:...

【数据结构】二叉树的实现(如:默认成员函数、(叶子)节点数、深度、四种遍历)

二叉树:树的每个节点最多有两个子节点。我们看下它的结构,有二叉链表结构与三叉链表结构,具体结果如我摘自《C++Primer》中的图。650) this.width=650;" src="http://...

广义表的创建及成员函数的实现

广义表是非线性的结构,是线性表的一种扩展,是有n个元素组成有限序列。 广义表的定义是递归的,因为在表的描述中又得到了表,允许表中有表。 例如: (1)A = () (2)B = (...

数据结构数组和广义表课件

  • 2014年10月16日 21:53
  • 861KB
  • 下载

第6次数据结构上机(数组和广义表的基本运算实现)

实验名称:数组和广义表的基本运算实现 指导教师:           王莹洁               专业班级:       计163-1         姓   名:      曹欣...

数据结构课程设计广义表

  • 2013年01月11日 09:50
  • 1.07MB
  • 下载

VC/MFC 广义表画图程序(数据结构)

  • 2009年09月13日 15:12
  • 429KB
  • 下载

c语言版数据结构(奇迹冬瓜)-数组和广义表(稀疏矩阵的转置算法一)

//稀疏矩阵 /* |0 12 9 0 0 0 0| |0 0 -3 0 0 15| |0 0 0 0 0 0 0|...

数据结构-数组和广义表

  • 2008年09月25日 18:17
  • 1.58MB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【数据结构】广义表的默认成员函数、深度、大小、打印
举报原因:
原因补充:

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