线性表的顺序实现，顺序表的初始化，查找，插入，删除

#include<iostream>
using namespace std;
#define MAXSIZE 100//定义数组最大为100
#define OK 1//将OK替换为1  下边俩都是这个意思
#define ERROR 0
#define OVERFLOW -2
typedef int Status;  //int 类型起了一个别名为 Status。在后续的代码中，可以使用 Status 来代替 int 类型 
typedef int ElemType;//这个也是
typedef struct//定义了一个顺序表，一个顺序表中又两个东西
               1.当前数组长度length
               2.当前数组地址elem
{
    ElemType *elem;
    int length;
}SqList;//给这个顺序表起了个别名sqlist 
Status InitList(SqList &L)                
//构造一个空的顺序表L
{
    
}
Status ListInsert (SqList &L ,int i ,ElemType e)
// 在顺序表L的第i个元素之前插入新的元素e
{    
    
}
Status ListDelete(SqList &L,int i)
//在顺序表L中删除第i个元素
{    
}
Status GetElem(SqList L,int i,ElemType &e)
//用e返回线性表L中第i个数据元素的值。
{    
 
}
int LocateELem(SqList L,ElemType e)
// 在顺序线性表L中查找第1个值与e相等的位置。
// 若找到，则返回其在L中的位序，否则返回0。
{    

}
void ListPrint(SqList L) 
//打印整张表
{
    int i;
    int e;
    if (L.length ==0) 
    {
        cout<<"NULL\n";
        return ;
    }
    for(i=1;i<=L.length ;i++)
    {    
        GetElem(L,i,e);
        cout<<e<<" ";
    }
    cout<<endl;
}
int main()
{
    SqList L;//定义类型为sqlList的变量L
    int i,n,x;
    InitList(L);
    cin>>n;
    for(i=1;i<=n;i++)   //构造表
    {
        cin>>x;
        ListInsert(L,i,x);
    }
    cin>>i;//输入i
    ListDelete(L,i); //删除第i个元素
    ListPrint(L); //打印整张表
    cin>>x;
    cout<<"Locate="<<LocateELem(L,x)<<endl;//查找x的位置
    return 0;
}

这是已有的代码。

输入样例为：输入一组数据，该组测试实例第一行首先是n（1<=n<=30），之后是n个元素，它们之间用空格隔开。
第二行输入要删除第几个元素。
第三行输入要查找的元素。

第一个构造空的顺序表函数IntList(SqList &L):

Status InitList(SqList &L)//空的顺序表
{
    L.elem=new ELemType[MAXSIZE];//没有数组 那就new一个，长度为多少？不知道，所以就用最大长度来表示
    L.length=0;//顺序表刚开始长度是0，没开辟之前长度是一个随机数字
    return OK;//告诉函数我做完了 可以返回了
}

&L为c++的引用，它的功能是可以改变实参的值。

第一句代码new 也可以理解为为顺序表分配了一个大小为MaxSize的数组，用new来开辟空间

第二个插入函数为：

Status ListInsert(SqList &L,int i,ELemType e)//&L改变了实参的值
{
    int j;
    if(i<1 || i>L.length+1) return ERROR;//判断插入的位置不能比原有的顺序表长度长
    if(L.length==MAXSIZE) return ERROR;//如果当前长度等于数组最大了，那是不是就插入不了了
    for(j=L.length-1;j>=i-1;j--)//用一个循环，比如要插入二个元素，那么就从第二个开始把第三个挪到第四个位置，为插入的那个元素提供个位置。
        L.elem[j+1]=L.elem[j];
    L.elem[i-1]=e;//把要插入的值赋给对应的位置
    L.length++;//插入之后，数组的长度就对应加了个1
    return OK;//告诉函数 我做完了，可以退出了。
}

1. SqList 是一个自定义的数据结构，表示顺序表，通过引用传递给函数，以便在函数内部修改顺序表的内容。

2. 函数接受三个参数：

   • SqList &L：表示传入的顺序表。
   • int i：表示要插入元素的位置。
   • ELemType e：表示要插入的元素值。

3. 函数中的逻辑：

   • 首先，检查是否插入位置合法，即 i 的范围应该在 1 到 L.length+1 之间，否则返回错误状态 ERROR。
   • 然后，检查顺序表是否已经满了，如果已满则无法插入，同样返回错误状态 ERROR。
   • 接着，从插入位置开始，依次向后移动元素，为新元素腾出位置。
   • 将元素 e 插入到位置 i-1 处。
   • 最后，更新顺序表的长度，并返回操作状态 OK。

总体来说，这段代码实现了在顺序表中插入元素的功能，通过改变顺序表中元素的位置来实现插入操作。前提是顺序表有足够的空间来插入新元素，并且插入位置合法。

第三个删除函数：

Status ListDelete(SqList &L,int i)
{
    int j;
    if(i<1 || i>L.length) return ERROR;//检查是否删除位置合法，即 i 的范围应该在 1 到 L.length之间 否则返回错误状态ERROR
    for(j=i;j<=L.length-1;j++)//与插入一样，比如我要删除第二个元素，那我就把第三个元素的值给第二个，第四个的值给第三个，依次类推就可
        L.elem[j-1]=L.elem[j];
    L.length--;//删除了，那对应的长度就要减一个长度了
    return OK;
}

这段代码是一个函数 ListDelete，用于在顺序表 L 中删除第 i 个位置（从1开始）的元素。以下是代码的分析：

1. SqList 是一个自定义的数据结构，表示顺序表，通过引用传递给函数，以便在函数内部修改顺序表的内容。

2. 函数接受两个参数：

   • SqList &L：表示传入的顺序表。
   • int i：表示要删除元素的位置。

3. 函数中的逻辑：

   • 首先，检查要删除的位置是否合法，即 i 的范围应该在 1 到 L.length 之间，否则返回错误状态 ERROR。
   • 然后，从位置 i 开始，将后面的元素依次向前移动一个位置，覆盖被删除的元素。
   • 最后，减少顺序表的长度，并返回操作状态 OK。

总体来说，这段代码实现了在顺序表中删除指定位置的元素的功能。值得注意的是，删除元素后，顺序表的长度会相应减少一个单位。前提是顺序表中存在要删除的位置，并且位置合法。

第四个查找函数：

int LocateElem(SqList L,ELemType e)
{
    int i;
    for(i=1;i<L.length;i++)//遍历数组一个一个查找，找到了返回当前第几个元素找到的
        if(L.elem[i-1]==e)//注意的是数组是从0开始的 比如a[0]=5对应的顺序表为第一个元素为5/
            return i;
    return 0;
}

千万千万要记得数组是从0开始的，顺序表元素是从1开始的

而且这个函数传递的L就不是c++的引用

这段代码是一个函数 LocateElem，用于在顺序表 L 中查找元素值为 e 的元素，并返回其在顺序表中的位置。以下是代码的分析：

1. 函数接受两个参数：

   • SqList L：表示传入的顺序表（这里是按值传递，而不是引用传递）。
   • ELemType e：表示要查找的元素值。

2. 函数返回一个整数，即元素值为 e 的元素在顺序表中的位置（从1开始），如果未找到则返回 0。

3. 函数中的逻辑：

   • 通过 for 循环遍历顺序表中的每个元素，从第一个元素开始（i=1）。
   • 在循环中，检查当前位置的元素是否等于要查找的元素值 e，如果相等，则返回当前位置 i。
   • 如果遍历完整个顺序表都没有找到目标元素，则返回 0，表示未找到。

总体来说，这段代码实现了在顺序表中查找指定元素值的功能，返回该元素在顺序表中的位置。前提是顺序表中存在要查找的元素。值得注意的是，返回的位置是从1开始计数的。

第五个取值函数：

//获取顺序表长度L中第i个位置的元素  并存储在参数e中
Status GetElem(SqList L,int i,ELemType &e)//e要使用c++的引用来改变实参的值，
{
    if(i<1||i>L.length)return ERROR;//先判断要取的值在不在顺序表这个范围内
    e=L.elem[i-1];//第i个元素值赋给e，因为数组第一个为a[0]  顺序表第一个元素为1，所以要用elem【i-1】来表示
    return OK;
}

所有代码中使用 L. 来访问顺序表 L 中的成员变量或成员函数是因为 L 是一个结构体对象，使用点运算符 . 可以访问结构体对象的成员。L.elem[]是：L结构体对象中的数组

总体全部代码：

#include<iostream>
using namespace std;
#define MAXSIZE 100
#define ERROR 0
#define OK 1
#define OVERFLOW -2
typedef int Status;
typedef int ELemType;
typedef struct{
    ELemType *elem;
    int length;
}SqList;
Status InitList(SqList &L)
{
    L.elem=new ELemType[MAXSIZE];
    L.length=0;
    return OK;
}
Status ListInsert(SqList &L,int i,ELemType e)
{
    int j;
    if(i<1 || i>L.length+1) return ERROR;
    if(L.length==MAXSIZE) return ERROR;
    for(j=L.length-1;j>=i-1;j--)
        L.elem[j+1]=L.elem[j];
    L.elem[i-1]=e;
    L.length++;
    return OK;
}
Status ListDelete(SqList &L,int i)
{
    int j;
    if(i<1 || i>L.length) return ERROR;
    for(j=i;j<=L.length-1;j++)
        L.elem[j-1]=L.elem[j];
    L.length--;
    return OK;
}
Status GetElem(SqList L,int i,ELemType &e)
{
    if(i<1||i>L.length)return ERROR;
    e=L.elem[i-1];
    return OK;
}
int LocateElem(SqList L,ELemType e)
{
    int i;
    for(i=1;i<L.length;i++)
        if(L.elem[i-1]==e)
            return i;
    return 0;
}
void ListPrint(SqList L)
{
    int i;
    int e;
    if(L.length==0)
    {
        cout<<"NULL\n";
        return ;
    }
    for(i=1;i<=L.length;i++)
    {
        GetElem(L,i,e);
        cout<<e<<" ";
    }
    cout<<endl;
}
int main()
{
    SqList L;
    int i,n,x;
    InitList(L);
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>x;
        ListInsert(L,i,x);
    }
    cin>>i;
    ListDelete(L,i);
    ListPrint(L);
    cin>>x;
    cout<<"Locate="<<LocateElem(L,x)<<endl;
    return 0;
}

顺序表：线性表顺序实现，顺序存储（数组）是随机读取的

              链式存储（链表）是顺序读取。