顺序表代码合集（可运行）

静态存储

#include 

using namespace std;

#define MaxSize 10          // 定义最大长度

typedef struct SqList {
int data [MaxSize];          // 用静态的数组存放类型为整数的数据元素，本例中的ElemType是int
int length;                  // 数组当前长度
}SqList;                   // 顺序表的类型定义

void InItList(SqList &L) {
    for (int i = 0; i < MaxSize; i++) {
        L.data[i] = 0; // 将所有元素值初始化为0，不然可能会有“脏数据”
    }
    L.length = 0;    // 设置顺序表初始长度为0
}

// 按位插入操作，在表L中的第i个位置上插入指定元素e。
bool ListInsert(SqList &L, int i, int e)
{
    if(i< 1 || i > L.length + 1) {// 判断i的范围是否有效，即在1到L.length,如果不在返回false
        return false;
    }
    for(int j = L.length; j >= i; j--) {// 将第i个元素及其之后的元素全部后移，从后往前依次进行
        L.data[j] = L.data[j - 1];
    }
    L.data[i- 1] = e;
    L.length++;
    return true;
}

// 将顺序表L的第i个元素删除，并将第i个元素的值返回给e
bool ListDelete(SqList &L, int i, int &e)
{
    // 判断位置是否合法
    if(i < 1 || i > L.length) {// 被删除位置应该在1到L.length之间
        return false;
    }
    e = L.data[i - 1];
    for(int j = i; j < L.length; j++) {
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    return true;
}

// 按位查找
int getElem(SqList L, int i)
{
    return L.data[i - 1];
}

int LocateElem(SqList L, int e)
{
    for(int i = 1; i <= L.length; ++i) {
        if(L.data[i - 1] == e) {
            return i;
        }
    }
    return -1; //查找失败，返回-1；
}

void Print(SqList L)
{
    for(int i = 0; i < L.length; i++) {
        cout << L.data[i] << " ";
    }
    cout << endl;
}
int main()
{
    SqList L;              // 声明一个顺序表，开始在内存中分配存储顺序表的存储空间，包括数组和存储length的存储空间
    InItList(L);               // 初始化一个顺序表，赋初值0
    ListInsert(L, 1, 3);
    ListInsert(L, 2, 3);
    ListInsert(L, 2, 5);
    int e = 0;
    ListDelete(L,1,e);
    Print(L);
    cout << e << " " << getElem(L, 1) << " " << LocateElem(L, 5)<<  endl;
    return 0;
}


// 输出
5 3
3 5 1

动态存储实现

#include 

using namespace std;
#define INIT_SIZE 2

typedef struct SeqList {
    int* data;
    int maxSize;
    int length;
}SeqList;

void InItList(SeqList& L)   // 用malloc申请一块连续的存储空间，用来存放数组
{
    L.data = (int*)malloc(INIT_SIZE * sizeof(int));
    L.maxSize = INIT_SIZE;
    L.length = 0;
    cout<< "L.maxSize:" < L.length + 1) {
    //     return false;
    // }
    assert(i >= 1 && i <= L.length + 1);
    if(L.length >= L.maxSize) {// 容量不够，扩容一倍
        DoubleSize(L);
    }
    for(int j = L.length; j >= i; j--) {// 将最后一个元素到第i个元素依次前移
        L.data[j] = L.data[j - 1];// 将下标j(原来存放的j + 1)存放前一个元素，也即把元素后移，用后一个坐标承接
    }
    L.data[i - 1] = e;      // 将待插入的值存放入第i个位置
    L.length++;             // 不要忘了更新长度，插入一个元素，长度+1
    return true;            // 全程没有错误，返回true
}

bool ListDelete(SeqList &L, int i, int &e)
{
    if (i < 1 || i > L.length) {
        return false;
    }
    e = L.data[i -1];
    for (int j = i; j < L.length; ++j) {// 把从i+1到末尾的元素都前移
        L.data[j - 1] = L.data[j];      // 第j个位置放第j+1个元素
    }
    L.data[L.length - 1] = 0;
    L.length--;
    return true;
}

//在顺序表L中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SeqList L, int e)
{
    for (int i = 0; i < L.length; ++i) {
        if (L.data[i] == e) {
            return i +1;        // 如果数组下标为i的元素等于e，返回其位序i+1
        }
    }
    return 0;               // 如果退出循环，返回0,查找失败
}
void Print(SeqList L, int &e) {
    for(int i = 0; i < L.length; ++i) {// 遍历数组全部元素
        cout << L.data[i] << " ";      // 依次输出每一个值
    }
    cout << "e:" << e << endl;
}
int main ()
{
    SeqList L;                                          // 声明一个顺序表，开辟了一个int指针空间，两个int空间
    int e;
    InItList(L);                                      // 初始化顺序表，为顺序表分配内存空间并赋初值，开辟了INIT_SIZE个int空间
    ListInsert(L, 1, 3);
    ListInsert(L, 2, 5);
    // IncreaseSize(L, 5);                                 // 开辟一个新的内存空间，把数据复制过来，更新顺序表容量，最后释放原来的内存空间
    ListInsert(L, 3, 4);
    ListDelete(L, 2, e);
    cout << "4local:" << LocateElem(L, 4) << endl;
    Print(L, e);
    return 0;
}


// 输出
L.maxSize:2
L.maxSize:4
4local:2
3 4 e:5