关于线性表中顺序表的静态实现方式和动态实现方式

数据结构一

一、关于线性表中顺序表的静态实现方式和动态实现方式

1. 静态实现方式

// 顺序表的实现------静态分配
#include <stdio.h>

#define MaxSize 10

typedef struct{
    int data[MaxSize];
    int length;
}SqList;

//基本操作——初始化一个顺序表
void InitList(SqList *L){
    L->length=0;
}

//插入一个元素
int ListInsert(SqList *L,int i,int e){
    if(i<1||i>L->length+1){
        return 0;//判断i的范围是否有效
    }
    if(L->length>=MaxSize){
        return 0;//当前存储空间已经满了
    }
    for (int j = L->length; j >= i; j--) {
        L->data[j]=L->data[j-1];
    }
    L->data[i-1]=e;
    L->length++;
    return 1;
}
//删除一个元素
int ListDelete(SqList* L,int i){
    if(i<1||i>L->length){
        return 0;
    }
    for(int j=i;j<L->length;j++){
        L->data[j-1]=L->data[j];
    }
    L->length--;
    return 1;
}
//查找第i个元素：按位查找操作
int GetElem(SqList* L,int i){
    if(i<1||i>L->length)
        return -1;
    return L->data[i-1];
}
//查找元素：按值查找操作
int LocateElem(SqList* L,int e){
    for(int i=0;i<L->length;i++){
        if(L->data[i]==e){
            return i+1;
        }
    }
    return 0;
}
int main()
{
    SqList L;                //声明顺序表
    InitList(&L);            //初始化顺序表
    //准备初始化数据
    L.data[0]=1;
    L.data[1]=2;
    L.data[2]=3;
    L.data[3]=5;
    L.length=4;
    //查找第i个元素,按位查找
    int IsFindGetElem=GetElem(&L,2);
    printf("Find %dth is %s,the value is %d\n",2,IsFindGetElem>0?"success":"fail",IsFindGetElem);
    //查找元素,按值查找
    int IsFindLocateElem= LocateElem(&L,5);
    printf("Find %d is %s,the key is %d\n",5,IsFindLocateElem>0?"success":"fail",IsFindLocateElem);
    //插入元素
    int IsInsert=ListInsert(&L,3,10);
    printf("Insert is success?:%s\n",IsInsert==1?"success":"fail");
    //删除元素
    int IsDelete=ListDelete(&L,2);
    printf("Delete is success?:%s\n",IsDelete==1?"success":"fail");
    for(int i=0;i<L.length;i++){
        printf("L->data[%d]=%d,L->length=%d\n",i,L.data[i],L.length);
    }
    return 0;
}

运行结果:

Find 2th is success,the value is 2
Find 5 is success,the key is 4
Insert is success?:success
Delete is success?:success
L->data[0]=1,L->length=4
L->data[1]=10,L->length=4
L->data[2]=3,L->length=4
L->data[3]=5,L->length=4

Process finished with exit code 0

2.动态实现方式

// 顺序表的实现------动态分配
#include "stdio.h"
#include "stdlib.h"

#define  InitSize 10 //顺序表的初始化长度

typedef struct {
    int *data;    //指示动态分配数组的指针
    int MaxSize;  //顺序表的最大容量
    int length;   //顺序表的当前长度
}SeqList;

void InitList(SeqList *L){
    //用malloc函数申请一片连续的存储空间
    L->data=(int*)malloc(InitSize*sizeof(int));
    L->length=0;
    L->MaxSize= InitSize;
}
void InCreaseSize(SeqList *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);
}
int main(){
    SeqList L;     //声明一个顺序表
    InitList(&L);  //初始化顺序表
    InCreaseSize(&L,5);
    for (int i = 0; i < InitSize+5; ++i) {
        printf("i:%d,data:%d\n",i,L.data[i]);
    }
    return 0;
}

运行结果：

i:0,data:12738496
i:1,data:0
i:2,data:12714320
i:3,data:0
i:4,data:1635017028
i:5,data:1701728000
i:6,data:1986622020
i:7,data:1852785509
i:8,data:1701672307
i:9,data:977485170
i:10,data:1702057308
i:11,data:2019324786
i:12,data:1651466601
i:13,data:1331456353
i:14,data:1917085038