第6课

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

【顺序存储结构定义】

线性表的顺序存储结构，指的是用一段地址连续的存储单元依此存储线性表中的数据元素。

【设计思路】

可以用一维数组来实现顺序存储结构的线性表。

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

【顺序存储线性表类的组成】

DTLib顺序存储结构线性表相关的类有三个：

 - SeqList：顺序存储结构线性表的抽象父类

 - StaticList：SeqList的子类，使用原生数组作为顺序存储空间

 - DynamicList：SeqList的子类，申请连续堆空间作为顺序存储空间

2. SeqList类的实现

【设计要点】

 - 抽象类模板

 - 仅实现顺序存储结构线性表的关键操作（增，删，改，等）

 - 存储空间的位置和大小由子类完成

 - 提供数组操作符，方便快速获取元素

【接口设计】

template <typename T>
class SeqList : public List<T>
{
public:
    bool insert(int i, const T &e);    //在位置i处插入新元素e
    bool insertTail(const T &e);       //在尾部插入新元素e
    bool remove(int i);                //删除位置i处的元素
    bool set(int i, const T &e);       //设置位置i处的元素为e
    int find(const T &e) const;        //查找e在线性表中第一次出现的位置；若e不存在，则返回-1
    bool get(int i, T &e) const;       //获取位置i处的元素，通过参数e返回
    T get(int i) const;                //获取位置i处的元素，通过返回值返回
    int length() const;                //获取线性表长度
    void clear();                      //清空线性表

    //数组访问形式，提供const和非const版本
    T &operator[] (int i);
    T &operator[] (int i) const;

    //顺序存储空间的大小，由子类实现
    virtual int capacity() const = 0;
};

【插入功能实现】

1. 检查目标位置是否合法
2. 检查是否有剩余存储空间可供插入
3. 将目标位置处元素及目标位置之后的所有元素后移一个位置
4. 将新元素插入目标位置
5. 线性表长度加1

//在位置i处插入新元素e
bool insert(int i, const T &e)
{
    bool ret = (0 <= i) && (i <= m_length);       //目标位置可以为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_array[i] = e;
        m_length++;
    }

    return ret;
}

//在尾部插入新元素e
bool insertTail(const T &e)
{
    return insert(m_length, e);
}

【删除功能实现】

1. 检查目标位置是否合法
2. 将目标位置之后的所有元素前移一个位置
3. 线性表长度减一

//删除位置i处的元素
bool remove(int i)
{
    bool ret = (0 <= i) && (i < m_length);

    if (ret)
    {
        //将目标位置之后的所有元素前移一个位置
        for (int p = i + 1; p < m_length; p++)
        {
            m_array[p - 1] = m_array[p];
        }

        m_length--;
    }

    return ret;
}

【设置功能实现】

1. 检查目标位置合法性
2. 将目标位置处的元素替换为要设置的值

//设置位置i处的元素为e
bool set(int i, const T &e)
{
    bool ret = (0 <= i) && (i < m_length);

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

    return ret;
}

【查找功能实现】

1. 遍历顺序表，比较目标元素与各位置处元素是否相等
2. 若相等，结束遍历，返回其位置；若遍历结束仍未找到，则返回-1

//查找e在线性表中第一次出现的位置；若e不存在，则返回-1
int find(const T &e) const
{
    int ret = -1;

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

    return ret;
}

【获取功能实现】

1. 检查目标位置合法性
2. 将目标位置作为数组下标获取元素

//获取位置i处的元素，通过参数e返回
bool get(int i, T &e) const
{
    bool ret = (0 <= i) && (i < m_length);

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

    return ret;
}

//获取位置i处的元素，通过返回值返回
T get(int i) const
{
    T ret;

    if (get(i, ret))
    {
        return ret;
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
    }
}

【获取长度与清空功能实现】

1. 获取线性表长度，直接将m_length返回
2. 清空线性表，只需将m_length清0

//获取线性表长度
int length() const
{
    return m_length;
}

//清空线性表
void clear()
{
    m_length = 0;
}

【数组访问方式实现】

1. 检查目标位置合法性
2. 对于非const版本，直接将目标位置处元素返回
3. 对于const版本，先对当前对象进行const_cast强制类型转换，去除其const属性，然后再调用非const版本的数组访问函数

//数组访问，用于非const对象
T &operator[] (int i)
{
   if ((0 <= i) && (i < m_length))
   {
       return m_array[i];
   }
   else
   {
       THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
   }
}

//数组访问，用于const对象
T &operator[] (int i) const
{
    return (const_cast<SeqList<T> &>(*this))[i];
}

【SeqList完整实现】

以下是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:
    //在位置i处插入新元素e
    bool insert(int i, const T &e)
    {
        bool ret = (0 <= i) && (i <= m_length);       //目标位置可以为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_array[i] = e;
            m_length++;
        }

        return ret;
    }

    //在尾部插入新元素e
    bool insertTail(const T &e)
    {
        return insert(m_length, e);
    }

    //删除位置i处的元素
    bool remove(int i)
    {
        bool ret = (0 <= i) && (i < m_length);

        if (ret)
        {
            //将目标位置之后的所有元素前移一个位置
            for (int p = i + 1; p < m_length; p++)
            {
                m_array[p - 1] = m_array[p];
            }

            m_length--;
        }

        return ret;
    }

    //设置位置i处的元素为e
    bool set(int i, const T &e)
    {
        bool ret = (0 <= i) && (i < m_length);

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

        return ret;
    }

    //查找e在线性表中第一次出现的位置；若e不存在，则返回-1
    int find(const T &e) const
    {
        int ret = -1;

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

        return ret;
    }

    //获取位置i处的元素，通过参数e返回
    bool get(int i, T &e) const
    {
        bool ret = (0 <= i) && (i < m_length);

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

        return ret;
    }

    //获取位置i处的元素，通过返回值返回
    T get(int i) const
    {
        T ret;

        if (get(i, ret))
        {
            return ret;
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
        }

        return ret;
    }

    //获取线性表长度
    int length() const
    {
        return m_length;
    }

    //清空线性表
    void clear()
    {
        m_length = 0;
    }

    //数组访问，用于非const对象
    T &operator[] (int i)
    {
       if ((0 <= i) && (i < m_length))
       {
           return m_array[i];
       }
       else
       {
           THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
       }
    }

    //数组访问，用于const对象
    T &operator[] (int i) const
    {
        return (const_cast<SeqList<T> &>(*this))[i];
    }

    //顺序存储空间的最大容量，由子类实现
    virtual int capacity() const = 0;
};

}

#endif // SEQLIST_H

3. StaticList类的实现

【设计要点】

 - 类模板

 - 使用原生数组作为顺序存储空间

 - 使用模板参数决定数组大小

【设计实现】

StaticList实现比较简单，就不多说了，只需要注意一点：在构造函数中将父类的m_array指针指向子类的m_space数组。

#ifndef STATICLIST_H
#define STATICLIST_H

#include "SeqList.h"

namespace DTLib
{

template <typename T, int N>
class StaticList : public SeqList<T>
{
protected:
    T m_space[N];
public:
    StaticList()
    {
        this->m_array = m_space;
        this->m_length = 0;
    }

    int capacity() const
    {
        return N;
    }
};

}

#endif // STATICLIST_H

 【StaticList类简单测试】

下面写一点代码对StaticList类进行简单的功能测试。

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

using namespace DTLib;
using namespace std;

int main()
{ 
    StaticList<int, 5> list;

    for (int i = 0; i < (list.capacity() - 1); i++)
    {
        list.insert(list.length(), i);
    }

    list.insertTail(4);

    for (int i = 0; i < list.length(); i++)
    {
        cout << list.get(i) << endl;
    }

    cout << endl;

    list[4] = 16;
    cout << list[4] << endl;

    int v = 0;
    list.set(3, 9);
    list.get(3, v);
    cout << v << endl;

    cout << endl;

    try
    {
        list[5] = 5;
    }
    catch(const Exception &e)
    {
        cout << e.location() << endl;
        cout << e.message() << endl;
    }

    return 0;
}

运行结果如下，初步测试功能正常。

4. DynamicList类的实现

【设计要点】

 - 类模板

 - 申请连续堆空间作为顺序存储空间

 - 支持动态设置（resize）顺序存储空间的大小

class DynamicList : public SeqList<T>
{
protected:
    int m_capacity; 
public:
    DynamicList(int capacity); //动态申请存储空间
    int capacity() const;      //获取存储空间大小
    void resize(int capacity); //重设存储空间大小
    ~DynamicList();            //释放存储空间
};

 【设计实现】

首先实现构造和析构函数，分别用于申请和释放顺序存储空间。

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 ...");
    }
}

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

然后实现父类的纯虚函数capaticy()。

int capacity() const
{
    return m_capacity;
}

最后实现DynamicList的关键函数resize()，该函数用于在当前存储空间过大或过小时重设存储空间。

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++)
            {
                /*
                 * 若T是类类型，且[]操作符被重载，那么array[i]是有可能产生异常的；
                 * 但DTLib无法顾全这一点，只能由使用者保证。
                */
                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 resize DynamicList object ...");
        }
    }
}

其中，resize()第22~28行的设计可以保证函数异常安全。所谓函数异常安全，指的是在调用函数时如果有异常被抛出，那么：

 - 对象内的任何成员仍然能保持有效状态

 - 没有数据的破坏以及资源的泄露

如果将第22~28行代码改为如下方式（非异常安全），那么当T为类类型的时候delete[] this->m_array会触发析构函数调用，析构函数中有可能抛出异常，

使后面三行代码无法执行，最终造成DynamicList对象的数据被破坏。

delete[] this->m_array;

this->m_array = array;
this->m_length = length;
this->m_capacity = capacity;

【DynamicList完整实现】

#ifndef DYNAMICLIST_H
#define DYNAMICLIST_H

#include "SeqList.h"
#include "Exception.h"

namespace DTLib
{

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++)
                {
                    /*
                     * 若T是类类型，且[]操作符被重载，那么array[i]是有可能产生异常的；
                     * 但DTLib无法顾全这一点，只能由使用者保证。
                    */
                    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 resize DynamicList object ...");
            }
        }
    }

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

}

#endif // DYNAMICLIST_H

【DynamicList功能测试】

测试代码：

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

using namespace DTLib;
using namespace std;

int main()
{ 
    DynamicList<int> list(5);

    for (int i = 0; i < list.capacity(); i++)
    {
        list.insert(0, i);
    }

    for (int i = 0; i < list.length(); i++)
    {
        cout << list[i] << endl;
    }

    cout << endl;

    try
    {
        list[5] = 5;
    }
    catch(const Exception &e)
    {
        cout << e.location() << endl;
        cout << e.message() << endl;

        list.resize(10);
        list.insert(5, 50);

        for (int i = 0; i < list.length(); i++)
        {
            cout << list[i] << endl;
        }

        cout << endl;
    }

    list.resize(3);

    for (int i = 0; i < list.length(); i++)
    {
        cout << list[i] << endl;
    }

    return 0;
}

测试结果：

5. 小结

1. StaticList通过模板参数定义顺序存储空间
2. DynamicList通过动态内存申请定义顺序存储空间
3. DynamicList支持动态重置顺序存储空间的大小
4. DynamicList中的resize()函数需要保证异常安全

注：本文整理于狄泰《数据结构开发实战教程》课程内容