简单顺序表

    线性表是具有相同数据类型的 n(n>=0) 个数据元素的有限序列其中 n 为表长，当 n = 0 时，线性表是一个空表。
    若用L命名线性表，则其一般表示为 L = (a1,a2,a3,a4……an)
    ai是线性表中的第 i 个元素，指线性表中的位序。从 1 开始。
    a1是表头元素，an是表尾元素。
    除第一个元素外，每个元素有且仅有一个直接前驱，除最后一个元素外，每个元素有且仅有一个直接后继。
    顺序表特点：
        1.随机访问，既可以在O(1)的时间内找到第i个元素
        2.存储密度高，每个节点只存储数据元素
        3.拓展容量不方便
        4.插入，删除操作不方便，需要移动大量元素
顺序表的类型声明：

//静态分配
#include<stdio.h>
#define MaxSize 10
typedef struct List *PtrTonode;
typedef PtrTonode List;
struct List
{
    int data[MaxSize];
    int length;
};
//动态分配
#include <stdio.h>
#include <stdlib.h>
#define InitSize 10
typedef struct List *PtrTonode;
typedef PtrTonode List;
struct List
{
    int *data;
    int MaxSize;
    int length;
};

InitList：初始化表，构造一个空的线性表，分配内存空间

//静态分配
int Initlist(List L)
{
    int i;
    for (i = 0; i < MaxSize; i++)
        L->data[i] = 0;
    L->length = 0;
}
//动态分配
void InitList(List L)
{
    L->data=(int *)malloc(InitSize*sizeof(int));
    L->length=0;
    L->MaxSize=InitList;
}
void IncreaseSize(List L,int len)
{//动态增加数组的长度
    int *p=L->data;
    L->data=(int *)malloc((L->MaxSize+len)*sizeof(int));
    for(int i=0;i<L->length;i++)
        L->data[i]=p[i];
    L->MaxSize=L->MaxSize+len;
    free(p);
}

DestroyList：销毁操作，销毁线性表并释放线性表L所占用的内存空间

int DestroyList(List L)
{
    free(L);
}

ListInsert：插入操作，在表L的第i个位置上插入指定元素

//静态插入
List ListInsert(List L,int a,int b)
{
    int j;
    if(a<1||a>L->length+1)//判断a的范围是否有效
        Error("False");
    if(L->length>=MaxSize)//判断L表是否已满
        Error("False");
    for(j=L->length;j>=a;j--)
        L->data[j]=L->data[j-1];
    L->data[a-1]=b;
    L->length++;
    return L;
}
//动态插入
List ListInsert(List L,int a,int b)
{
    int j;
    if(a<1||a>L->length+1)//判断a的范围是否有效
        Error("False");
    if(L->length>=InitSize)//判断L表是否已满
        Error("False");
    for(j=L->length;j>=a;j--)
        L->data[j]=L->data[j-1];
    L->data[a-1]=b;
    L->length++;
    return L;
}

ListDelete：删除操作，删除表L中第i个位置的元素，并返回删除元素值

List ListDelete(List L,int a)
{//删除第a个位序上的元素
    int j;
    if(a<1||a>L->length)
        Error("False");
    for(j=a;j<=L->length;j--)
        L->data[j-1]=L->data[j];
    L->length--;
    return L;
}

LocateElem：按值查找，在表L中查找具有给定关键字值元素

int LocateElem(List L,int a)
{
    return L->data[a-1];
}

GetElem：按位查找操作，获取表L中的i个位置的元素的值

int GetElem(List L,int a)
{
    int i;
    for(i=0;i<L->data;i++)
        if(a==L->data[i])
            return i+1;
}

Length：求表长，返回线性表L的长度，即L中数据元素的个数

int Length(List L)
{
    return L->length;
}

Printlist：输出操作，按前后顺序输出线性表L的所有元素值

void Printlist(List L)
{
    for(int i=0;i<L->length;i++)
        printf("%d",L->data[i]);
    return 0;
}

Empty：判空操作，若表L为空表，则返回true

int Empty(List L)
{//是空则返回1，否则返回0
    if(L->length==0)    
        return 1;
    else
        return 0;
}