顺序表的定义、初始化、销毁、插入、删除、查找

静态分配的顺序表操作： 

define maxsize 100;

//定义——静态分配
typedef struct {
  int data[maxsize];
  int length;
}SqList;

SqList L;
//初始化——静态顺序表
initList(SqList &L)
{
    for(int i=0;i<maxsize;i++)//赋初值可以省略，但是会有脏数据
       L.data[i]=0;
    L.legth=0;
}
//静态分配存在数组存满和内存浪费的问题

//判断顺序表是否为空——静态分配
bool Empty(SqList L){
    if(L.length==0)
        return true;
    else
        return false;
}
  
//插入——静态数组
bool ListInsert(SqList &L,int i,int e){//在第i个位置插入元素，下标为i-1
    //顺序表满了 插入失败
    if(i>=L.length+1||i<1)//注意排除隔空插入！
        return false;
    if(L.length>maxsize)
        return false;
    //找到第i-1个元素，将它后面的元素全部往后挪一位
    for(int j=L.length;j>=i;j--)
        L.data[j]=L.data[j-1];
    //插入元素
    L.data[i-1]=e;
    //更新数据
    L.length++;
    return true;
}
  
//删除——静态数组
void ListDelete(SqList &L,int i,int &e){
    //如果顺序表不空
    if(i>0&&i<=L.length){
        //找到第i个元素并返回
        e=L.data[i-1];
        //找到第i个元素，之后的元素全部往前挪
        for(int j=i;j<L.length;j++)
        {
            L.data[j-1]=L.data[j];
        }
        //更新数据
        L.length--;
    }
    else
        return flase;
}
  
//按值查找——静态分配
int LocateElem(SqList L,int e){
    for(int j=0;j<L.length;j++){
        if(L.data[j]==e){
            return j+1;//位序和下标不一样
            break;//返回找到的第一个e的位置
        }
    }
    return 0;
}
  
//按位查找——静态分配
int GetElem(SqList L,int i){
    //判断i的合法性
    if(i>=1&&i<=L.length){
        return L.data[i-1];
    }
}
  
//求表长
int Length(SqList L){
    return L.length;
}
  
//判空
bool Empty(SqList L){
    if(L.length==0)
        return true;
    else
        return false;
}

动态分配的顺序表操作：

//定义——动态分配
typedef struct{
  int * data;
  int length;
  int maxsize;
}SeqList;

SeqList L;
//初始化——动态顺序表
InitList(SeqList &L){
    L.data=(int *)malloc(sizeof(int)*Initsize);
    L.length=0;
    L.maxsize=Initsize;//申请多大的空间就有多大空间的内存分配
}

//动态顺序表增加长度
void IncreaseSize(SeqList &L,int len){
    //开辟一段新空间，将旧值复制，释放原来的空间
    //用p标记原来的那段空间的首地址
    int * p =L.data;
    //开辟一段新的长度增加了的内存
    L.data=(int *)malloc(sizeof(int)*(L.maxsize+len)
    for(int 0;i<L.length;i++)
        L.data[i]=p[i];
    //更新动态数组最大长度
    L.maxsize=L.length+len;//L.maxsize+len也行
    //释放原来的内存空间
    free(p);
} 

//按位查找——动态分配，和静态分配的按位查找一样
int GetElem(SeqList L,int i){
    //判断数据合法性
    if(i>0&&i<=L.length){
        return L.data[i-1];
        //注意这里动态分配的数据访问和普通数组访问一样！
        //虽然data是指针，但也可以用数组的方式访问。
    }
}

//按值查找——动态分配，和静态分配的按值查找一样
int LocateElem(SeqList L,int e){
    //从前往后遍历匹配
    for(int j=0;j<L.length;j++){
        if(L.data[j]==e){
            return j+1;//位序和下标不一样
            break;//写上break，只返回找到的第一个e的位置
        }
    }
    return 0;
}

//销毁顺序表
void DestoryList(SeqList * L){
    L->length = 0;
    L->maxsize = 0;
    free(L->data);
    L->data = NULL;
}