线性表的基本操作，包括：创建、插入、删除、查找等基本操作

标签： 数据结构

---

线性表是数据结构中最直观、最简单的一类抽象数据类型，本次需要使用顺序表来实现线性表，并编写相应的测试程序对你所创建的顺序表及单链表进行测试，以下给出测试样例：

输入数据格式：

• 第一行只有一个整型数N（0<N<100)，表明需要输入N行，每行表示一个操作（包括插入、删除、查找等）;

• 每行的操作格式为：操作码操作数据（其中操作数据可能包含多个）;操作码使用对应的英文字母表示，具体对应关系如下所示：

• 注：实际测试时操作码与操作数之间有一个空格，操作数之间也有一个空

操作(功能)	操作码	操作数格式说明	示例	示例说明
创建表	C	1个整数，表明创建表的长度	C 5	创建一个长度为5的表
删除表	W	无操作数，删除整个表	W	删除整个表
输出表	P	无操作数，将当前表中所有数据元素输出，每个元素之间有一个空格	P	输出当前表中国所有的数据，每个数据元素之间用一个空格作为间隔
获取表的长度	L	无操作数，获取表的长度	L	获取表的长度，并输出表的长度
获取节点数据域	E	1个整数表明需要获取的节点的下标（序号）	E 4	获取下标为4的节点的数据并输出
查找节点	F	1个数据域字段（ELEMTYPE,在本例中为整数）	F 8	查找表中是否存在数据域字段为8的节点，若存在则输出该节点的下标（序号）
前插节点	B	2个数据，第一个为下标（序号），第二个为数据（ELEMTYPE类型），本例中为整数	B 4 9	在下标为4的数据元素前插入一个新元素，新元素的数据域为9
后插节点	A	2个数据，第一个为下标（序号），第二个为（ELEMTYPE类型，本例中为整数）	A 4 9	在下标为4的数据元素后插入一个新元素，新元素的数据域为9
删除元素	D	1个数据域字段（ELEMTYPE,在本例中为整形数）	D 8	在表中删除数据域为8的第一个数据元素（如果存在多个数据的话）
删除节点	S	1个整数表明需要删除的节点的下标（序号）	S 3	在表中删除下标为3的节点
在表尾部添加节点	R	1个数据域字段（ELEMTYPE,在本例中为整形数）	R 2	在表的尾部添加一个数据元素，新添加的数据域为2

测试用例演示（具体指令请参照以上表格）：

以下为源码，包含三个文件 palist.h 、palist.cpp 、main.cpp

• palist.h

/**
* tool:codeblocks
*/
#include<iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;

struct SeqList
{
    int MAXNUM;
    int n;
    int *element;
};

typedef struct SeqList *PSeqList;

PSeqList createNullList_Seq(int m);//创建空表
int isNullList_qes(PSeqList palist);//空表反回1，其他0
int locat_seq(PSeqList palist,int x);//定位x在表中的位置
int insertPre_seq(PSeqList palist,int p,int x);//前插
int intertPost_seq(PSeqList palist,int p,int x);//后插
int deletP_seq(PSeqList palist,int p);//删除下标为p的元素
int deletV_seq(PSeqList palist,int x);
void destroySeqList(PSeqList palist); /*删除顺序表，包括删除顺序表的elements域及SeqList*/
int getVertexSeqList(PSeqList palist, int p, int* x);
void printSeqList(PSeqList palist);
int lengthSeqList(PSeqList palist);//求表长
int appendElemLnList(PSeqList palist, int x);/*在顺序表的尾部， 添加一个新的数据元素，其数据域为 x*/

• palist.cpp

#include "palist.h"
/**
*创建空表
*param m: 将要创建的表长度
*return PSeqlist
*/
PSeqList createNullList_Seq(int m)
{
    if(m <= 0)
    {
        cout<<"Error!"<<endl;
        return 0;
    }
    PSeqList palist = (PSeqList)malloc(sizeof(struct SeqList));
    if(palist != NULL)
    {
        palist->element = (int*)malloc(sizeof(int)*m);
        if(palist->element != NULL)
        {
            palist->MAXNUM = m;
            palist->n = 0;
            return palist;
        }
        free (palist);
    }
    cout<<"Out of space!!"<<endl;
    return NULL;
}

/**
*空表反回1，其他0
*/
int isNullList_qes(PSeqList palist)
{
    return (palist->n == 0);
}

/**
*定位x在表中的位置
*return
*存在:x的下标;  不存在:-1
*/
int locat_seq(PSeqList palist,int x)
{
    if(palist == NULL)
    {
        return -1;
    }
    int q;
    for(q = 0; q < palist->n; q++)
    {
        if(palist->element[q] == x)
        {
            return q;//返回元素下标
        }
    }
    return -1;//元素不存
}

/**
*前插,在位置p(下标)的前面插入元素x
* return -2 表为null
* return -1 溢出
* return 0 插入下标不合法
* return 1 插入成功
*/
int insertPre_seq(PSeqList palist,int p,int x)
{
    if(palist == NULL)
    {
        return -2;
    }
    int q;
    if(palist->n >= palist->MAXNUM)//溢出
    {
        cout<<"Overflow!"<<endl;
        return -1;
    }
    if(p < 0 || p > palist->n)//检查插入位置是否合法
    {
        cout<<"Not exist!"<<endl;
        return 0;
    }
    for(q = palist->n-1; q >= p; q--)
    {
        palist->element[q+1] = palist->element[q];//依次往后移
    }
    palist->element[p] = x;
    palist->n += 1;
    return 1;//插入成功的标志
}
/**
*后插
*/
int intertPost_seq(PSeqList palist,int p,int x)
{
    if(palist == NULL)
    {
        return -2;
    }
    int q;
    if(palist->n >= palist->MAXNUM)
    {
        cout<<"Overflow"<<endl;
        return -1;
    }
    if(p<0 || p>palist->MAXNUM)
    {
        cout<<"Not exist"<<endl;
        return 0;
    }
    for(q=palist->n-1;q>p;q--)
    {
      palist->element[q+1] = palist->element[q];
    }
    palist->element[p+1] = x;
    palist->n = palist->n+1;
    return 1;
}

/**
*删除下标为p的元素
*/
int deletP_seq(PSeqList palist,int p)
{
    if(palist == NULL)
    {
        return -1;
    }
    if(p < 0 || p > palist->n)
    {
        cout<<"Not exist"<<endl;
        return 0;
    }
    int q;
    for(q = p; q < palist->n-1; q++)
    {
        palist->element[q] = palist->element[q+1];
    }
    palist->n = palist->n-1;
    return 1;
}
/**
*在顺序表 list 中，删除第一个值
*为 x数据元素，如果存在的话
*/
int deletV_seq(PSeqList palist,int x)
{
    deletP_seq(palist,locat_seq(palist,x));
    return 0;
}
/**
*删除顺序表，包括删除顺序表的elements域及SeqList
*/
void destroySeqList(PSeqList palist)
{
    if(palist != NULL)
    {
       if(palist->element != NULL)
       {
           free(palist->element);
       }
       free(palist);
    }
    palist=NULL;
}

int getVertexSeqList(PSeqList palist, int p, int* x)
{
    if(p<0 || p>palist->n)
    {
        cout<<"Overflow"<<endl;
        return -1;
    }
    x = &palist->element[p];
    cout<<*x<<endl;
    return 1;

}

void printSeqList(PSeqList palist)
{
    for(int i = 0; i < palist->n; i++)
    cout<<palist->element[i]<<" ";
    cout<<endl;
}

int lengthSeqList(PSeqList palist)
{
    return palist->n;
}

int appendElemLnList(PSeqList palist, int x)
{
    if(palist == NULL)
    {
        return -1;
    }
    if(palist->n == palist->MAXNUM)
    {
        cout<<"Out of space!"<<endl;
        return 0;
    }
    palist->element[(palist->n)++] = x;
    return 1;
}

• main.cpp

#include "palist.h"

int main()
{
    char ch;
    int m,g,k;
    int a;
    int* x=NULL;
    PSeqList palist;
    cin>>m;
    while(m>=0)
    {
        ch=getchar();
        if(ch=='\n')
            m--;
        else
        {
        switch(ch)
        {
                case 'C':
                    cin>>g;
                    palist=createNullList_Seq(g);
                    break;
                case 'W':
                    destroySeqList(palist);
                    break;
                case 'P':
                    printSeqList(palist);
                    break;
                case 'L':
                    if(!isNullList_qes(palist))
                        cout<<lengthSeqList(palist)<<endl;
                    else
                        cout<<"0"<<endl;
                    break;
                case 'E':
                    cin>>g;
                    getVertexSeqList(palist,g,x);
                    break;
                case 'F':
                    cin>>g;
                    k=locat_seq(palist,g);
                    if(k==-1)
                        cout<<"Not found!"<<endl;
                    else
                        cout<<palist->element[k];
                    break;
                case 'B':
                    int d;
                    cin>>g>>d;
                    insertPre_seq(palist,g,d);
                    break;
                case 'A':
                    cin>>g>>a;
                        intertPost_seq(palist,g,a);
                    break;
                case 'D':
                    cin>>g;
                    deletV_seq(palist,g);
                    break;
                case 'S':
                    cin>>g;
                    deletP_seq(palist,g);
                    break;
                case 'R':
                    cin>>g;
                    appendElemLnList(palist,g);
                    break;
                }


        }

    }
    return 0;
}