顺序表——动态分配顺序表上的基本操作（初始化、遍历、插入、查找、删除、判空等）

---

顺序表的定义

 线性表的顺序存储又称顺序表。它是用一组地址连续的存储单元依次存储线性表中的数据元素，使得逻辑上相邻的两个元素在物理位置上也相邻。

 顺序表的特点：

1. 随机访问。通过首地址和元素序号可在时间O（1）内找到指定元素。
2. 存储密度高。每个结点只存储数据元素。
3. 逻辑上相邻的元素在物理上也相邻，故插入和删除操作需要移动大量元素。

---

顺序表上的操作

 在顺序表上的操作主要有：

• 初始化Init(&L)
• 求表长Length(L)
• 遍历表PrintList(L)
• 动态分配IncreaseSize(&L,n)
• 插入Insert(&L,i,e)
• 按值查找LocateElem(L,x)
• 按位查找GetElem(L,i)
• 删除操作Delete(&L,i,&x)
• 判空操作Empty(L)
• 销毁操作DestroyList(&L)

顺序表的类型描述：

#define InitSize 2   //定义线性表的初始长度
typedef struct Sqlist{
	int *data; //指示动态分配数组的指针
    int MaxSize,length; //数组的最大容量和当前长度
}Sqlist;

---

初始化

//初始化
void InitList(Sqlist &L){
    L.length = 0;
    L.MaxSize = InitSize;
    L.data = (int *)malloc(sizeof(int)*InitSize);//C 申请一片连续的存储空间
//     L.data = new int[InitSize]; //C++
}

---

求表长

//求表长
int Length(Sqlist L){
    return L.length;
}

---

遍历表

//遍历表
void PrintList(Sqlist L){
    for(int i=0; i<L.length; i++){
        cout<<L.data[i]<<" ";
    }
    cout<<endl;
}

---

动态分配

//动态分配
void IncreaseSize(Sqlist &L, int n){
    int *p = L.data;
    L.data = (int *)malloc(sizeof(int)*(L.MaxSize + n));  //C
//    L.data = new int[L.MaxSize + n];  //C++
    for(int i=0; i<L.length; i++){
        L.data[i] = p[i]; //将数据复制到新区域
    }
    L.MaxSize += n; //顺序表最大长度加n
    free(p); //释放原来的内存空间
}

---

插入操作

//插入操作：在顺序表L的第i个上插入x
void Insert(Sqlist &L, int i, int x){
    if(i<1 || i>L.length+1){
        cout<<x<<" Insert failed."<<endl;
        return;
    }
    if(L.length >= L.MaxSize){ //自动增长10个长度
        IncreaseSize(L,10); 
    }
    for(int j=L.length; j>=i; j--){
        L.data[j] = L.data[j-1];
    }
    L.data[i-1] = x;
    L.length++;
}

---

查找操作

  查找操作一般有两种方式：按值查找和按位查找，需要注意的是顺序表中元素的位序是从1开始的，而数组中元素的下标是从0开始的。

按值查找

//按值查找：返回顺序表L中第一个值为x的元素的位置
int LocateElem(Sqlist L, int x){
    for(int i=0; i<L.length; i++){
        if(L.data[i] == x)
            return i+1;  //返回元素位置
    }
    return -1;  //查找失败，返回-1
}

按位查找

//按位查找：返回顺序表中第i个元素的元素值
int GetElem(Sqlist L, int i){
    return L.data[i-1];
}

---

删除操作

//删除操作：删除顺序表L中第i个元素并返回其元素值
int Delete(Sqlist &L, int i, int &x){
    if(i<1 || i>L.length){
        return -1;
    }else{
        x = L.data[i-1];
        for(int j=i; j<L.length; j++){
            L.data[j-1] = L.data[j];
        }
        L.length--;
        return x;
    }
}

---

判空操作

//判空操作
int Empty(Sqlist L){
    return L.length==0? 1 : 0;
}

---

销毁操作

//销毁操作
void DestroyList(Sqlist &L){
    free(L.data);
    L.length = 0;
    L.MaxSize = 0;
    L.data = nullptr;  //令其为空指针
}

---

完整代码及实例

#include<bits/stdc++.h>
using namespace std;

#define InitSize 5   //定义线性表的初始长度
typedef struct Sqlist{
	int *data; //指示动态分配数组的指针
    int MaxSize,length; //数组的最大容量和当前长度
}Sqlist;

//初始化
void InitList(Sqlist &L){
    L.length = 0;
    L.MaxSize = InitSize;
    L.data = (int *)malloc(sizeof(int)*InitSize);//C 申请一片连续的存储空间
//     L.data = new int[InitSize]; //C++
}

//求表长
int Length(Sqlist L){
    return L.length;
}

//遍历表
void PrintList(Sqlist L){
    for(int i=0; i<L.length; i++){
        cout<<L.data[i]<<" ";
    }
    cout<<endl;
}

//动态分配
void IncreaseSize(Sqlist &L, int n){
    int *p = L.data;
    L.data = (int *)malloc(sizeof(int)*(L.MaxSize+n)); //C
//    L.data = new int[L.MaxSize + n];  //C++
    for(int i=0; i<L.length; i++){
        L.data[i] = p[i]; //将数据复制到新区域
    }
    L.MaxSize += n; //顺序表最大长度加n
    free(p); //释放原来的内存空间
}

//插入操作：在顺序表L的第i个上插入x
void Insert(Sqlist &L, int i, int x){
    if(i<1 || i>L.length+1){
        cout<<x<<" Insert failed."<<endl;
        return;
    }
    if(L.length >= L.MaxSize){ //自动增长10个长度
        IncreaseSize(L,10); 
    }
    for(int j=L.length; j>=i; j--){
        L.data[j] = L.data[j-1];
    }
    L.data[i-1] = x;
    L.length++;
}

//按值查找：返回顺序表L中第一个值为x的元素的位置
int LocateElem(Sqlist L, int x){
    for(int i=0; i<L.length; i++){
        if(L.data[i] == x)
            return i+1;  //返回元素位置
    }
    return -1;  //查找失败，返回-1
}


//按位查找：返回顺序表中第i个元素的元素值
int GetElem(Sqlist L, int i){
    return L.data[i-1];
}

//删除操作：删除顺序表L中第i个元素并返回其元素值
int Delete(Sqlist &L, int i, int &x){
    if(i<1 || i>L.length){
        return -1;
    }else{
        x = L.data[i-1];
        for(int j=i; j<L.length; j++){
            L.data[j-1] = L.data[j];
        }
        L.length--;
        return x;
    }
}

//判空操作
int Empty(Sqlist L){
    return L.length==0? 1 : 0;
}

//销毁操作
void DestroyList(Sqlist &L){
    free(L.data);
    L.length = 0;
    L.MaxSize = 0;
    L.data=nullptr; //令其为空指针
}

int main(){
    Sqlist L;
    InitList(L);
    Insert(L,1,1);
    Insert(L,2,2);
    Insert(L,3,3);
    Insert(L,1,4);
    Insert(L,2,5);
    Insert(L,6,6);
    cout<<"L的当前长度："<<L.length<<endl;
    cout<<"L的最大长度"<<L.MaxSize<<endl;
    PrintList(L);
    cout<<"1在顺序表中的位置为"<<LocateElem(L,1)<<endl;
    cout<<"顺序表中第4个元素是"<<GetElem(L,4)<<endl; 
    DestroyList(L);
    PrintList(L);
    cout<<Empty(L)<<endl;
    return 0;
}

运行结果：