数据结构(03)_顺序存储结构线性表

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据结构(03)_顺序存储结构线性表相关的知识,希望对你有一定的参考价值。

本节我们基于前面实现的数据结构类模板基础,继续完成基于顺序存储结构的线性表的实现,话不多说,继承关系图如下:
技术分享图片

14.线性表的本质和操作

14.1.线性表的表现形式

  • 零个多多个数据元素组成的集合
  • 数据元素在位置上是有序排列的
  • 数据元素的个数是有限的
  • 数据元素的类型必须相同

    14.2.线性表的抽象定义、性质

    线性表是具有相同类型的n(>=)个数据元素的有限序列,(a0, a1, a2... an-1),其中ai是表项,n是表长度。
    性质:

  • a0为线性表的第一个元素,只有一个后继
  • an-1为线性表的最后一个元素,只有一个前驱
  • 其他数据项既有后继,也有前驱
  • 支持逐项和顺序存储

    14.3.线性表的一些常用操作

  • 插入、删除数据元素
  • 获取、设置目标位置元素的值
  • 获取线性表的长度
  • 清空线性表
    示例代码:
    template <typename T>
    class list : public Object
    {
    public:
    virtual bool insert(int index, const T& e) = 0;
    virtual bool remove(int index) = 0;
    virtual bool set(int index, const T& e) = 0;
    virtual bool get(int index, T& e) const = 0;
    virtual bool length() const = 0;
    virtual bool clear() = 0;
    }

    14.4.总结:

    线性表是数据元素的有序并且有限的集合,其中的数据元素类型相同,在程序中表现为一个特殊的数据结构,可以使用C++中的抽象类来表示,用来描述排队关系的问题。

    15.线性表的顺序存储结构

    15.1.概念和设计思路

    定义:
    线性表的顺序存储结构,指的是用一段地址连续的存储单元依次存储线性表中的数据元素。
    技术分享图片
    设计思路:
    使用一维数组来实现存储结构:

    // 存储空间:T* m_array; 当前长度:int m_length;
    template <typename T>
    class SeqList : public List<T>
    {
    protected:
    T* m_array;
    int m_length;
    };

    15.2.顺序存储结构的元素操作

  • 获取:判断目标位置是否合法,将目标位置做为数组下标获取元素。
  • 插入:1.判断目标位置是否合法,将目标位置之后的元素后移一个位置,3.将新元素插入目标位置,4.线性表长度加1。(注意插入的点永远比元素会多一个)
  • 删除:1.判断目标位置是否合法,将目标位置之后的元素前移一个位置,3.线性表长度减1。

    15.3 List实现

template <typename T>
class List:public Object
{
protected:
    List(const List&);
    List& operator ==(const List&);

public:
    List(){}
    virtual bool insert(const T& e) = 0;
    virtual bool insert(int i,const T& e) = 0;
    virtual bool remove(int i) = 0;
    virtual bool set(int i,const T& e) = 0;
    virtual bool get(int i,T& e) const  = 0;
    virtual int length() const = 0;
    virtual void clear() = 0;
};

16.SeqList的设计要点

  • 抽象类模板,存储空间的大小和位置由子类完成;
  • 实现顺序存储结构线性表的关键操作(增、删、查、等);
  • 提供数组操作符重载,方面快速获取元素;

    template <typename T>
    class SeqList : public List<T>
    {
    protected:
    T* m_array;      // 顺序存储空间
    int m_length;        // 当前线性长度
    public:
    bool insert(int index, const T& e);
    bool remove(int index);
    bool set(int index, const T& e);
    bool get(int index, T& e) const;
    int length() const;
    void clear();
    
    // 顺序存储表的数组访问方式
    T& operator [] (int index);
    T operator [] (int index) const;
    
    // 顺序存储表的的容量
    virtual int capacity() const = 0;
    };

    思考:StaticList和DynamicList如何实现,差异在那里?是否可以将DynamicList做为StaticList的子类实现
    这两者的差异在于,后者可以动态指定线性表的大小和存储空间,由于两者的性质完全不同,所以不能实现为彼此的子类

    16.1SeqList实现


template <typename T>
class SeqList : public List<T>
{
protected:
    T* m_array;      // 顺序存储空间
    int m_length;    // 当前线性长度
public:

    bool insert(int index, const T& e)
    {
        bool ret = ( (index>=0) && (index<=m_length) ); // <= 因为可以插入的点,必然比当前元素多1

        if(ret && ( m_length < capacity() ))    // 当前至少有一个空间可插入
        {
            for(int p=m_length-1; p>=index; p--)
            {
                m_array[p + 1] = m_array[p];
            }

            m_array[index] = e;
            m_length++;
        }
        return ret;
    }

    bool insert(const T& e)
    {
        return insert(m_length, e);
    }

    bool remove(int index)
    {
        bool ret = ( (index>=0) && (index<m_length) );  // 目标位置合法 <m_length

        if(ret)
        {
            for(int p=index; p<m_length-1; p++)        // 注意思考此处的边界条件
            {
                m_array[p] = m_array[p+1];
            }

             m_length--;
        }

        return ret;
    }

    bool set(int index, const T& e)
    {
        bool ret = ( (index>=0) && (index<m_length) );

        if(ret)
        {
            m_array[index] = e;
        }

        return ret;
    }

    bool get(int index, T& e) const
    {
        bool ret = ( (index>=0) && (index<m_length) );

        if(ret)
        {
            e = m_array[index];
        }

        return ret;
    }

    int length() const
    {
        return m_length;
    }

    void clear()
    {
        m_length = 0;
    }

    // 顺序存储表的数组访问方式
    T& operator [] (int index)
    {
        if( (index>=0) && (index<m_length) )
        {
            return m_array[index];
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "index out of range...");
        }
    }

    T operator [] (int index) const
    {
        static_cast<SeqList<T>&>(*this)[index];    // 去除const属性,然后调用非const版本实现
    }

    // 顺序存储表的的容量
    virtual int capacity() const = 0;
};

}

#endif // SEQLIST_H

17.StaticList和DynamicList

17.1.StaticList的设计要点:

类模板

  • 使用原生数组做为顺序存储空间
  • 使用模板参数决定数组的大小
    template < typename T, int N >
    class StaticList : public SeqList <T>
    {
    protected:
    T m_space[];        // 顺序存储空间,N为模板参数
    public:
    StaticList();       // 指定父类成员的具体值
    int capacity() const;
    };

    17.1.1 StaticList实现

template < typename T, int N >
class StaticList : public SeqList <T>
{
protected:
    T m_space[N];       // 顺序存储空间,N为模板参数
public:
    StaticList()        // 指定父类成员的具体值
    {
        this->m_array = m_space;
        this->m_length = 0;
    }
    int capacity() const
    {
        return N;
    }
};

17.2.DynamicList的设计要点:

类模板

  • 申请连续堆空间做为顺序存储空间
  • 保证重置顺序存储空间的异常安全性
    函数异常安全的概念:
  • 不允许任何内存泄露,不允许破坏数据
  • 函数异常安全的基本保证:
  • 如果有异常抛出,对象内的任何成员任然能保持有效状态,没有数据破话或者资源泄露。
    template < typename T>
    class DynamicList : public SeqList <T>
    {
    protected:
    int capacity;       // 顺序存储空间的大小
    public:
    DynamicList(int capacity);   // 申请空间
    int capacity(void) const         // 返回capacity的值 
    // 重置存储空间的大小
    void reset(int capacity);
    ~DynamicList();             // 归还空间
    };

    17.2.1 DynamicList实现

template <typename T>
class DynamicList : public SeqList<T>
{

protected:
    int m_capacity;
public:
    DynamicList(int capacity)
    {
        this->m_array = new T[capacity];
        if(this->m_array != NULL)
        {
            this->m_length = 0;
            this->m_capacity = capacity;
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException,"No memory to create DynamicList object ...");
        }
    }

    int capacity()const
    {
        return m_capacity;
    }

    void resize(int capacity)
    {
        if(capacity != m_capacity)
        {
            T* array = new T[capacity];
            if(array != NULL)
            {
                int length = (this->m_length < capacity ? this->m_length : capacity);
                for(int i=0;i<length;i++)
                {
                    array[i] = this->m_array[i];
                }

                T* temp = this->m_array;
                this->m_array = array;
                this->m_length = length;
                this->m_capacity = capacity;
                delete[] temp;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException,"No memory to create DynamicList object ...");
            }
        }
    }

    ~DynamicList()
    {
        delete[] this->m_array;
    }
};

18.顺序存储结构线性表分析

18.1.时间复杂度

顺序存储结构线性表的效率为O(n),主要受其插入和删除操作的影响(譬如插入操作时,要插入位置之后的数据要向后挪动) 。

18.2.问题

两个长度相同的顺序存储结构线性表,插入、删除操作的耗时是否相同?
不相同,对顺序存储结构线性表,其插入、删除操作的复杂度还取决于存储的数据类型,譬如一个普通类型和一个字符串类型/类类型就完全不同(对于复杂数据类型,元素之间移动时必然耗时很多)。从这个角度考虑,线性表的效率存在隐患。

18.3.禁用拷贝构造和赋值操作。

贝构造和赋值操作会导致两个指针指向同一个地址,导致内存重复释放。对于容器类型的类,可以考虑禁用拷贝构造和赋值操作。
原因: 1、对于生活中容器类的东西,我们无法对其进行赋值(譬如生活中我们不可能将杯子中的水进行复制,只能使用另一个杯子重新去获取等量的水)。
实现:将拷贝构造和赋值操作函数定义为proteced成员,在类的外部,不能使用。

protected:
    List(const List&){}
List& operator = (const List&){}

18.4.线性表不能直接当做数组来使用

顺序存储结构线性表提供了数组操作符的重载,可以直接像数组一样,同过下标直接获取目标位置的元素,在具体的使用上类似数组,但是本质上不同,不能代替数组使用:

  • 必须先进行插入操作,才能对其内部的数据进行操作。
  • 原生数组是自带空间的,可以直接操作。

以上是关于数据结构(03)_顺序存储结构线性表的主要内容,如果未能解决你的问题,请参考以下文章

2.2_线性表的顺序存储结构

线性表的顺序存储结构之顺序表类的实现_Java

线性表的顺序存储结构

线性表-顺序结构存储

数据结构——基于顺序存储结构的线性表

数据结构_顺序表