C++数据结构第15课、线性表的顺序存储结构

• 顺序存储的定义
  线性表的顺序存储结构，指的是用一点段地址连续的存储单元依次存储线性表中的数据元素
  
• 设计思路
  — 可以用一维数组来实现顺序存储结构
  存储空间：T* m_array
  当前长度：int m_length
  

1、顺序存储结构元素的 获取 操作 virtual bool get(int i, T& e)const = 0;

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

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

2、顺序存储结构元素的 设置 操作 virtual bool set(int i, T& e) = 0;

— 判断目标位置是否合法
— 对目标位置直接赋值

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

3、顺序存储结构元素的 插入 操作 virtual bool insert(int i, const T& e) = 0;
（这个算法有必要看一下，一定是从后往前的次序，前给后赋值）

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

bool SeqList<T>::insert(int i, const T& e)
{
    bool ret = (i >= 0)&&(i <= m_length);          	   //两根手指有三种插入的方法，所以这里必须要等号
    ret = ret && (m_length < capacity());     		   //插入后我们要保证加上插入的数据整体不能超过最大存储量
    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;
}

4、顺序存储结构元素的 删除 操作 virtual bool delete(int i) = 0;（后给前赋值）

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

bool SeqList<T>::remove(int i)
{
    bool ret = (i >= 0)&&(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;
}

获取长度以及清空没什么难度，这里就不一一赘述。

SeqList.h

#ifndef SEQLIST_H
#define SEQLIST_H

#include <List.h>
#include <Exception.h>

namespace DTLib
{

template <typename T>
class SeqList : public List<T>
{
protected:
    T* m_array;
    int m_length;

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

template <typename T>
bool SeqList<T>::insert(int i, const T& e)
{
    bool ret = (0 <= i && i <= m_length);                       //插入会多一个位置的选择，所以这里变成 <=
    ret = ret && (m_length + 1 <= capacity());                  //判断长度是否越界,或者m_length < capacity()

    if(ret)
    {
        for(int p = m_length-1; p >= i; p--)                    //插入要往后移位, 最后一位 m_length-1 移到 m_length 的地方
        {
            m_array[p+1] = m_array[p];
        }
        m_array[i] = e;
        m_length++;
    }
    else
    {
        THROW_EXCEPTION(IndexOfBoundException, "Parameter i is invalid...");
    }

    return ret;
}

template <typename T>
bool SeqList<T>::insert(const T& e)
{
    return insert(m_length, e);
}

template <typename T>
bool SeqList<T>::remove(int i)
{
    bool ret = (0 <= i && i < m_length);
    if(ret)
    {
        for(int p = i; p < m_length-1; p++)                     //删除 数据要往前移位, n个数据只需要移 n-1 次
        {
            m_array[p] = m_array[p+1];
        }
        m_length--;
    }
    else
    {
        THROW_EXCEPTION(IndexOfBoundException, "Parameter i is invalid...");
    }

    return ret;
}

template <typename T>
bool SeqList<T>::set(int i, const T& e)
{
    bool ret = (0 <= i && i < m_length);
    if(ret)
    {
        m_array[i] = e;
    }
    else
    {
        THROW_EXCEPTION(IndexOfBoundException, "Parameter i is invalid...");
    }

    return ret;
}

template <typename T>
bool SeqList<T>::get(int i, T& e)const
{
    bool ret = (0 <= i && i < m_length);
    if(ret)
    {
        e = m_array[i];
    }
    else
    {
        THROW_EXCEPTION(IndexOfBoundException, "Parameter i is invalid...");
    }

    return ret;
}

template <typename T>
int SeqList<T>::length()const
{
    return m_length;
}

template <typename T>
void SeqList<T>::clear()
{
    m_length = 0;
}

template <typename T>
T& SeqList<T>::operator[](int i)
{
    if(0 <= i && i < m_length)
    {
        return m_array[i];
    }
    else
    {
        THROW_EXCEPTION(IndexOfBoundException, "Parameter i is invalid...");
    }
}

template <typename T>
T SeqList<T>::operator[](int i)const
{
    return const_cast<SeqList<T>&>(*this)[i];
}

}
#endif // SEQLIST_H