数据结构----顺序表（C++实现）

顺序表

---

顾名思义，就是按顺序排列的表。

1. 在顺序表中，各个表象的逻辑顺序和其存放的物理顺序一致。
2. 在对顺序表的访问中，通过下标，既可以顺序访问，又可以随机访问。
   

顺序表的定义

描述顺序表的存储表示有两种方式：静态方式和动态方式
静态方式

#define maxSize 100
typedef int T;
typedef struct
{
    T data[maxSize];
    int n;
}SeqList;

动态方式

typedef int T;
typedef struct
{
    T *data;
    int maxSize,n;
}SeqList;

动态存储中存储数组的空间在执行程序过程中通过动态分分配语句分配，达到扩充存储数组的目的。所以一般选择动态存储方式。

代码实现

#include<iostream>
#include<stdlib.h>
using namespace std;

const int defaultSize = 100;

// 定义
template <class T>
class SqList
{
private:
    T *data; // 存放顺序表中的元素
    int maxsize; // 最大容量
    int last;//当前已经存的最后位置
    void reSize(int newSize);//改变data数组的空间大小

public:
    SqList(int sz = defaultSize)// 构造函数
    {
        if (sz > 0)
        {
            maxsize = sz;
            last = -1;
            data = new T[maxsize];

            if (data == NULL)
            {
                cout << "分配失败" << endl;
                exit(1);
            }

        }
    }
    SqList(SqList<T>& L)// 复制构造函数
    {
        maxsize = L.Size();
        last = L.length() - 1;
        T value;
        data = new T[maxsize];
        if (data == NULL)
            cout << "分配失败" << endl;
        for (int i = 0; i <= last; i++)
            data[i] = L.GetData(i - 1);
    }
    ~SqList()// 析构函数
    {
        delete[] data;
    }

    //计算表最大容量
    int Size() const
    {
        return maxSize;
    }

    //计算表长度
    int length() const
    {
        return last + 1;
    }

    //搜索x在表中的位置
    int Search(T& x) const
    {
        for (int i = 0; i <= last; i++)
        {
            if (data[i] == x)
                return i + 1
        }
        return 0;
    }

    //查看i位置的内容
    bool GetData(T& i,T& x)
    {
        if (i > 0 || i <= last + 1)
        {
            x = data[i - 1];
            return true;
        }   
        return false;
    }

    //在第i项插入x的值
    bool SetData(int i, T& x)
    {
        if (last == maxsize - 1)    //如果表满，不能插入
            return false;
        if (i >= 0 && i <= last + 1)    //插入位置之后的所有元素后移一位
        {
            for (int j = last; j >= i; j--)
            {
                data[j + 1] = data[j];
            }
            data[i] = x;
            last++;
            return true;
        }
        return false;
    }

    //删除第i项，并返回
    bool Remove(int i, T& x)
    {

        if (i > 0 && i <= last + 1)
        {
            x = data[i - 1];
            for (int j = i - 1; j < last; j++)
                data[j] == data[j + 1];
            last--;
            return true;
        }
        return false;
    }

    //判断表是否为空
    bool IsEmpty()
    {
        return (last == -1) ? true : false;
    }

    //判断表是否已满
    bool IsFull()
    {
        return (last == maxsize - 1) ? true : false;
    }

    //输入
    void input()
    {
        cout << "开始建立顺序表，请输入表中元素个数：" << endl;
        while (1)
        {
            int length;
            cin >> length;
            last = length - 1;
            if (last <= (maxsize-1))
                break;
            cout << "超过范围" << endl;
        }
        cout << "输入表中元素" << endl;
        for (int i = 0; i <= last; i++)
        {
            cin >> data[i];
        }
    }

    //输出
    void output()
    {
        if (last >= 0)
        {
            for (int i = 0; i <= last; i++)
                cout << data[i] << " ";
        }
        else
            cout << "顺序表为空" << endl;
    }
};

int main()
{
    int i = 0;
    int x = 0;
    SqList<int> L;
    L.input();
    L.output();
    cout << "选择要查看的位置" << endl;
    cin >> i;
    L.GetData(i,x);
    cout << "目标元素：" << x << endl;
    cout << "想要插入的位置和插入的值：" << endl;
    cin >> i >> x;
    L.SetData(i,x);
    L.output();
    return 0;
}

优缺点分析

优点

1. 无需为结点间的逻辑关系分配额外的存储空间，存储利用率高。
2. 可以方便的随机存取表中的数据，存取速度快。

缺点

1. 在表中插入或删除元素时，为了保证物理内存的顺序，需要移动其他的元素位置，平均需要移动一般的元素，运行效率低。
2. 顺序表占用连续空间，动态分配内存时可能难以找到合适的空间地址。