目录

M1. 静态 

M2. 动态

//顺序表(线性表的顺序存储)
//-----静态-----
//定义,初始化,打印,插入,删除,按位查找,按值查找

//顺序表(线性表的顺序存储)
//-----静态-----
//定义,初始化,打印,插入,删除,按位查找,按值查找

#include 
#define MaxSize 10
typedef struct{
    int data[MaxSize];
    int length;
}SqList;

//声明各种基本操作
void InitList(SqList &L);//初始化顺序表
void InitList1(SqList &L);//另外一种初始化方式,数组中的数仍然是随机生成的
void InitList2(SqList &L);//实际运用中会使用到的
void PrintList(SqList L);//打印顺序表
bool ListInsert(SqList &L,int i,int e);//插入操作
bool ListDelete(SqList &L,int i,int &e);//删除操作
int GetElem(SqList L,int i);//按位查找
int LocateElem(SqList L,int e);//按值查找


int main(){
    SqList L;
    InitList2(L);
    PrintList(L);
    ListInsert(L,3,9);//若i = 0，或者i >= 7，插入失败，打印出的顺序表和插入前相同
    PrintList(L);
    int e = -1;
    ListDelete(L,2,e);
    PrintList(L);
    ListDelete(L,6,e);//若i = 0,或者i >= 6,删除失败,打印出的顺序表和插入前相同
    PrintList(L);
    GetElem(L,2);
    GetElem(L,6);
    LocateElem(L,9);
    return 0;
}


//初始化顺序表
void InitList(SqList &L){
    for (int i = 0; i < MaxSize; ++i) {
        L.data[i] = 0;
    }
    L.length = 0;
}

//另外一种初始化方式,数组中的数仍然是随机生成的
void InitList1(SqList &L){
    L.length = 0;
}

//实际运用中会使用到的
void InitList2(SqList &L){
    for (int i = 0; i < MaxSize; ++i) {
        L.data[i] = 0;
    }
    for(int i = 0;i < 5;i++){
        L.data[i] = i;
    }
    L.length = 5;
}

//打印顺序表
void PrintList(SqList L){
    for (int i = 0; i < MaxSize; ++i) {
        printf("%d ",L.data[i]);
    }
    printf("n");
}

//插入操作
bool ListInsert(SqList &L,int i,int e){
    if(i < 1 || i > L.length + 1)//注意这边不是i > MaxSize
        return false;
    if(L.length >= MaxSize)
        return false;
    for (int j = L.length-1; j >= i-1 ; j--) {
        L.data[j+1] = L.data[j];
    }
    L.data[i-1] = e;
    L.length++;
    return true;
}

//删除操作
bool ListDelete(SqList &L,int i,int &e){
    if(i < 1 || i > L.length)
    return false;
    e = L.data[i-1];
    for (int j = i; j < L.length; ++j) {
        L.data[j-1] = L.data[j];
    }
    L.length--;
    return true;
}

//按位查找
int GetElem(SqList L,int i){
    if(i < 0 || i > L.length)
        printf("查找失败!n");
    else
        printf("%dn",L.data[i-1]);
}

//按值查找
int LocateElem(SqList L,int e){
    for (int i = 0; i < L.length; ++i){
        if(e == L.data[i])
            printf("%d",i+1);//注意这边是i+1而不是i;
    }
    return 0;
}

M2. 动态

//顺序表(线性表的顺序存储)
//-----动态-----
//定义,初始化,扩容,打印,插入,删除,按位查找,按值查找

//顺序表(线性表的顺序存储)
//-----动态-----
//定义,初始化,扩容,打印,插入,删除,按位查找,按值查找

#include 
#include 
#define InitSize 10//默认的最大长度
typedef struct{
    int *data;//指向data类型数据的指针
    int MaxSize;//顺序表的最大容量，初始时，最大容量 = 默认的最大长度
    int length;//顺序表的当前长度
}SeqList;

//声明各种基本操作
void InitList(SeqList &L);//初始化顺序表
void InitList2(SeqList &L);//实际运用中会使用到的
void IncreaseSize(SeqList &L,int len);//扩容
void PrintList(SeqList L);//打印链表
bool ListInsert(SeqList &L,int i,int e);//插入操作
bool ListDelete(SeqList &L,int i,int &e);//删除操作
int GetElem(SeqList L,int i);//按位查找
int LocateElem(SeqList L,int e);//按值查找


int main(){
    SeqList L;
    InitList2(L);
    PrintList(L);
    IncreaseSize(L,10);
    PrintList(L);
    ListInsert(L,2,9);
    PrintList(L);
    int e = -1;
    ListDelete(L,2,e);
    PrintList(L);
    GetElem(L,2);
    LocateElem(L,1);
}

//初始化顺序表
void InitList(SeqList &L){
    L.data = (int*)malloc(sizeof(int)*InitSize);
    L.length = 0;
    L.MaxSize = InitSize;
}

//实际运用中会使用到的
void InitList2(SeqList &L){
    L.data = (int*)malloc(sizeof(int)*InitSize);
    L.MaxSize = InitSize;
    for (int i = 0; i < 5; ++i) {
        L.data[i] = i;
    }
    L.length = 5;
}

//打印顺序表
void PrintList(SeqList L){
    for (int i = 0; i < L.MaxSize; ++i) {
        printf("L.data[%d] = %dn",i,L.data[i]);
    }
}

//扩容
void IncreaseSize(SeqList &L,int len){
    int *p;
    p = L.data;
    L.data = (int*)malloc(sizeof(int)*(L.MaxSize + len));
    for (int i = 0; i < L.length; ++i) {
        L.data[i] = p[i];
    }
    L.MaxSize = L.MaxSize + len;
    free(p);
}

//插入
bool ListInsert(SeqList &L,int i,int e){
    if(i < 1 || i > L.length + 1)
        return false;
    if(L.length >= L.MaxSize)
        return false;
    for (int j = L.length-1; j >= i-1 ; j--) {
        L.data[j+1] = L.data[j];
    }
    L.data[i-1] = e;
    L.length++;
    return true;
}

//删除
bool ListDelete(SeqList &L,int i,int &e){
    if(i < 1 || i > L.length)
    return false;
    e = L.data[i-1];
    for (int j = i; j < L.length; ++j) {
        L.data[j-1] = L.data[j];
    }
    L.length--;
    return true;
}

//按位查找
int GetElem(SeqList L,int i){
    if(i < 0 || i > L.length)
        printf("查找失败!n");
    else
        printf("%dn",L.data[i-1]);
}

//按值查找
int LocateElem(SeqList L,int e){
    for(int i = 0 ; i < L.length ; i++)
    {
        if(L.data[i] == e)
            printf("%dn",i+1);
    }
    return 0;
}