线性表的顺序存储——顺序存储结构的抽象实现

1，本文完成顺序存储结构线性表的抽象实现：

　　1，SeqList 还是一个抽象类，这里仅实现线性表的关键操作，但是还是不能生成具体对象；

       2，关键操作虽然指定，但是顺序存储的指定没有在 SeqList 中完成，所以还是抽象类，不能生成具体对象；

 

      

2，SeqList 设计要点：

       1，抽象类模板，存储空间的位置和大小由子类完成；

       2，实现顺序存储结构线性表的关键操作（增删查等）；

       3，提供数组操作符，方便快速获取元素（因为是顺序存储结构，可以重载数组操作符）；

3，SeqList 具体函数接口（增删设获长清操容）：

     

4，顺序存储线性表实现：

#ifndef SEQLIST_H
#define SEQLIST_H

#include "Object.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)    // n + 5 => O(n)
    {
        bool ret = ((0 <= i) && (i <= m_length));
        ret = ret && (m_length <= capacity());  // 要插入元素，当插入后长度要加 1，此时小于号正好合适

        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 insert(const T& e)   // 在线性表的尾部插入一个元素；
    {
        return insert(m_length, e);
　　 }

    bool remove(int i)   // O(n)
    {
        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;
　　 }

/* 通过参数 e 来返回目标位置，而没有通过返回值返回，是由于目标位置可能不合法，不合法就返回 false，也就是 get() 操作用来说明当前操作是否合法*/
    bool get(int i, T& e) const
    {
        bool ret = ((0 <= i) && (i < m_length));

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

        return ret;
　　 }

/*
    int get(int i) const
    {
        int ret = -1;

        if(get(i, ret))
        {
            return ret;
        }

        return ret;
    }
*/

    int find(const T& e) const     //O(n)
    {
        int ret = -1;

        for(int i=0; i<m_length; i++)
        {
            if(m_array[i] == e)
            {
                ret = i;

                break;
            }
        }

        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, "Parameter i is invalid ..." );
        }
　　 }

    // 这里考虑了 const 和非 const 对象
    T operator[] (int i) const
    {
        return (const_cast<SeqList<T>&>(*this))[i];
　　 }

    //顺序存储空间的最大容量，顺序存储空间的指定没有在这个类中指定，在//其子类中完成的，所以具体实现要放在子类中完成；
    virtual int capacity() const = 0;
};

}
#endif // SEQLIST_H

5，顺序链表测试代码：

#include <iostream>
#include "SeqList.h"

using namespace std;
using namespace DTLib;

int main()
{
　　 SeqList<int>* l;
    return 0;
}