線性表的基本操作，包括：創建、插入、刪除、查找等基本操作

標籤： 數據結構

---

線性表是數據結構中最直觀、最簡單的一類抽象數據類型，本次需要使用順序表來實現線性表，並編寫相應的測試程序對你所創建的順序表及單鏈表進行測試，以下給出測試樣例：

輸入數據格式：

• 第一行只有一個整型數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;
}