线性表的顺序实现

题目

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

第二组输入样例
6 1 2 3 4 5 6
1
7

第三组输入样例
6 1 2 3 3 4 5
6
3

输出格式:

输出两行，第一行是完成操作的最终的顺序表所有元素，用空格间隔。
第二行输出查找的元素所在的位置。详见样例输出。
第一组输出样例
1 1 4 5 6
Locate=3

第二组输出样例
2 3 4 5 6
Locate=0

第三组输出样例
1 2 3 3 4
Locate=3

输入样例:

6 1 1 3 4 5 6
3
4

输出样例:

1 1 4 5 6 
Locate=3

分析过程：

1.函数结果状态代码

#define OK 1
#define ERROR 0
#define OVERFLOW -2

2.数据结构表示

//Status，ElemType是函数返回值类型，其值是函数结果状态代码
typedef int Status;
typedef int ElemType;

3.顺序表的存储结构 

#define MAXSIZE 100         //顺序表可能达到的最大长度
typedef struct
{
    ElemType *elem;        //存储空间的基地址，指向数据元素的基地址
    int length;           //当前长度
}Sqlist;                  //顺序表的结构类型为 Sqlist 

4.顺序表的初始化

a.开辟空间，使elem指向空间的基地址；

b.将表的当前长度设为0。

Status InitList(Sqlist &L){
    L.elem=new ElemType[MAXSIZE];        //分配大小为MAXSIZE的数组空间
    if(!L.elem) exit(OVERFLOW);          //存储分配失败退出
    L.length=0;                          //空表长度为0
    return OK;                           //状态返回 
}

5.顺序表的取值

a.判断指定的位置序号 i 值是否合理（1<=i<=L.length），若不合理，则返回ERROR。

b.若 i 值合理，则将第 i 个数据元素L.elem[i-1]赋给参数e，通过e返回第 i 个数据元素的传值。

Status GetElem(Sqlist L, int i,ElemType &e){
    if(i<1||i>L.length) return ERROR;         //判断i值是否合理，若不合理，返回ERROR
    e=L.elem[i-1];                            //elem[i-1]单元存储第i个数据元素
    return OK;
}

6.顺序表的查找

a.从第一个元素起，以次将其值和e相比较，若找到值与e相等的元素L.elem[i]，则查找成功，返回该元素的序号i+1。

b.若查遍整个顺序表都没有找到，则查找失败，返回0。

Status LocatElem(Sqlist L,ElemType e){
    int i;
    for(i=0;i<L.length;i++)                    //查找成功，返回序号i+1
        if(L.elem[i]==e) return i+1;           //查找失败，返回0
    return 0;
}

7.顺序表的插入

a.判断插入位置i是否合法，若不合法则返回ERROR。

b.判断顺序表的存储空间是否已满，若满则返回ERROR。

c.将的n个至第i个位置的元素依次向后移动一个位置，空出第i个位置（i=n+1时无须移动）。

d.将要插入的新元素e放入第i个位置。

e.表长加1。

Status ListInsert(Sqlist &L,int i,ElemType e){
    int j;
    if(i<1||i>L.length+1) return ERROR;         //i值不合法
    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;                             //将新元素e放入第i个位置
    L.length++;                                //表长加1
    return OK;
}

8. 顺序表的删除

a.判断删除位置i是否合法，若不合法则返回ERROR。

b.将第i+1个至第n个元素依次向前移动一个位置（i=n）。

c.表长减1.

Status ListDelete(Sqlist &L,int i){
    int j;
    if(i<1||i>L.length) return ERROR;        //i值不合法
    for(j=i;j<=L.length-1;j++)                 
        L.elem[j-1]=L.elem[j];               //被删除元素之后的元素前移 
    L.length--;                              //表长减1     
    return OK;
}

合并结果如下：

#include<iostream>
using namespace std;
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#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];
    if(!L.elem) exit(OVERFLOW);
    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;
}
//查找
Status LocatElem(Sqlist L,ElemType e){
    int i;
    for(i=0;i<L.length;i++)
        if(L.elem[i]==e) return i+1;
    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="<<LocatElem(L,x)<<endl;
}