线性表之顺序存储详解

1、顺序存储的定义

• 是指用一段地址相连的存储单元依次存储线性表中的数据元素

 2、设计思路

可以用一维数组实现顺序存储结构

 

包括：

• 存储空间：T*     m_array
• 当前长度：int   m_length

class SeqList: public List<T>
{
protected:
    T* m_array;//指向一个数组
    int m_length;//记录线性表的长度
}

3、元素的获取

• 判断目标位置是否合法
• 将目标位置作为数组下标获取元素

bool SeqList<T>::get(int i,T& e) const
{
    bool ret=((0<=i)&&(i<m_length));
    
    if(ret)
    {
        e=m_array[i]
    }
    return  ret; 
}

4、数据的insert

• 判断目标位置是否合法
• 将目标位置之后的所有元素后移一个位置
• 将新元素加入目标位置
• 线性表长度加1

bool SeqList<T>::insert(int i,const T& e)
{
    bool ret =((0<=i)&&(i <m_length));
    ret= ret&&((m_length+1)<=capacity));
    
    if(ret)
    {
        for(int p=m_length-1;p>=i;p--)
        {
            m_array[p+1]=m_array[p];
        }
        
        m_ayyay[i]=e;
        m_length++;
    }
    return ret ;  
}

5、数据的delete

• 判断目标位置是否合法
• 将目标位置后的所有的元素前移一个位置
• 线性表长度减1

bool SeqList<T>::remove(int i)
{
    bool ret=((0<=i)&&(i<m_length));
    
    if(ret)
    {
        
        for(int p=i;p<m_length-1;p++)
        {
            m_array[p]=m_array[p+1];
        }
        m_length--;
    }
    
    return ret;     
}

完整代码为：

#ifndef SEQLIST_H
#define SEQLIST_H
#include "list.h"
#include "Exception.h"

namespace DataStructureLib
{

    template <typename T>;
    class Seqlist:public List <T>
    {
    private:
        T* m_array;//顺序存储空间
        int m_length;//当前链表长度
    public:
        bool insert(int i, const T& e)
        {
            bool ret=(0<=i)&&(i  <=m_length);
            ret=ret&&(m_length<capcity());

            if(ret)
            {
                for(int p=m_length-1;p>=i;p--)
                {
                    m_array[p+1]=m_array[p];
                }
                m_array[i]=e;
                m_length++;
            }

            return ret;
        }

        bool remove(int i)
        {
            bool ret=(0<=i)&&(i  <=m_length);

            if(ret)
            {
                for(int p=i;p<m_length-1;p--)
                {
                    m_array[p]=m_array[p+1];
                }
                m_length--;
            }

            return ret;
        }

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

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

            return ret;
        }

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

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

            return ret;
        }

        int length() const
        {
            return  m_length;
        }

        void clear()
        {
            m_length=0;
        }

        //顺序存储线性表数组访问方式
        T& operator[](int i)   //
        {
            bool ret=(0<=i)&&(i  <=m_length);

            if(ret)
            {
                return m_array[i];
            }
            else
            {
                THROW_EXCEPTION(IndexOutOfBoundsException,"Paramara i is invalid... ");
            }

        }

        T operator [](int i) const// 重载   即如果调用了这个函数就说明了当前的对象是一个const对象
        {
            return  const_cast<Seqlist<T>&>(*this)[i];//将当前对象的const属性剔除（const_cast<Seqlist<T>&>(*this)） (即当前对象的类型变成了Seqlist<T>&，非const类型)，进而使用上面一个[]重载的函数
        }

        //顺序存储空间的容量
        virtual int capacity()=0;//子类来完成
    };

}
#endif // SEQLIST_H

小结：

Seqlist也是一个抽象类，其结构：静态线性表和动态线性表