9.18顺序表的编写

 这是看英雄哥的代码实现的顺序表，有最基础的增删改查的功能，这里还是写一下我的理解

1.首先是定义一个结构体变量，里面的变量内容有，整型指element，顺序表也就是element的

大小和容量size,capacity（这里的*element就是顺序表的地址）

2.然后定义函数SequentialListInit（）用来初始化顺序表，也就是给定要开辟的空间大小来开辟顺序表。

3.SequentialListDestroy（）第三个函数是用来销毁顺序表，因为顺序表达内存空间是手动开辟在堆区的需要手动释放首先判断表内是否有元素，有点话free,然后使顺序表的指针指向空，容量和大小都赋值为0。

4.SequentialListSize（）用来返回顺序表长度

5.SequentialListInsert（）用来向顺序表插入元素的函数，传入参数分别为结构体list的指针（这里我不认为list为顺序表而是包含含顺序表的一个变量），还有要插入的索引的位置，还有元素，然后判断传入的索引值是否有效，还要判断当前顺序表是否满，如果满了就双倍扩容，注意这里用realloc扩容后会保留原来数据，可能地址会变所以用newElement接受了一下，然后让顺序表指针指向他完成扩容，接着就是插入元素了，从后往前遍历，然后这里有一个关于约不越界的问题        （由于循环是从 list->size 开始并递减到 index + 1，因此不会访问到 list->elements[list->size]（这是一个未定义的行为，因为 list->size 是当前元素的数量，而有效的索引范围是 [0, list->size - 1]）。但是，您确实在循环之后将新元素放置在 list->elements[index] 上，这是安全的，因为 index 是一个有效的索引（假设它小于 list->size））--------------------------

这里就是将index和index之后的元素向后一动一位，插入元素，长度加一

6.SequentialListDelete（）用于删除函数同时判断索引值是否有效，这里呢就是按照要删除的index将数组从后往前动，同时主数组元素越界问题

7................................

#include<stdio.h>  
#include<stdlib.h>  
  
typedef struct {  
    int *elements;  
    size_t size;  
    size_t capacity;  
} SequentialList;  
  
void SequentialListInit(SequentialList *list, int capacity) {  
    list->elements = (int*)malloc(sizeof(int) * capacity);  
    if (!list->elements) {  
        printf("内存分配失败\n");  
        exit(1);  
    }  
    list->size = 0;  
    list->capacity = capacity;  
}  
  
void SequentialListDestroy(SequentialList *list) {  
    if (list->elements) {  
        free(list->elements);  
    }  
    list->elements = NULL;  
    list->size = 0;  
    list->capacity = 0;  
}  
  
size_t SequentialListSize(const SequentialList *list) {  
    return list->size;  
}  
  
void SequentialListInsert(SequentialList *list, int index, int element) {  
    if (index < 0 || index > list->size) {  
        printf("无效输入\n");  
        return;  
    }  
    if (list->size == list->capacity) {  
        int *newElements = (int*)realloc(list->elements, sizeof(int) * list->capacity * 2);  
        if (!newElements) {  
            printf("扩容失败\n");  
            return;  
        }  
        list->elements = newElements;  
        list->capacity *= 2;  
    }  
    for (size_t i = list->size; i > index; --i) {  
        list->elements[i] = list->elements[i - 1];  
    }  
    list->elements[index] = element;  
    ++list->size;  
}  
  
void SequentialListDelete(SequentialList *list, int index) {  
    if (index < 0 || index >= list->size) {  
        printf("无效输入\n");  
        return;  
    }  
    for (size_t i = index; i < list->size - 1; i++) {  
        list->elements[i] = list->elements[i + 1];  
    }  
    --list->size;  
}  
  
int SequentialListFind(const SequentialList *list, int element) {  
    for (size_t i = 0; i < list->size; i++) {  
        if (list->elements[i] == element) {  
            return i;  
        }  
    }  
    return -1;  
}  
  
int SequentialListIndex(const SequentialList *list, int index) {  
    if (index < 0 || index >= list->size) {  
        printf("无效输入\n");  
        return -1;  
    }  
    return list->elements[index];  
}  
  
void SequentialListSet(SequentialList *list, int index, int element) {  
    if (index < 0 || index >= list->size) {  
        printf("无效输入\n");  
        return;  
    }  
    list->elements[index] = element;  
}  
  
int main() {  
    SequentialList list;  
    SequentialListInit(&list, 10);  // 初始容量设为10  
    for (int i = 0; i < 10; i++) {  
        SequentialListInsert(&list, i, i * 10);  
    }  
    printf("Size : %d\n", SequentialListSize(&list));  
    int elem=SequentialListIndex(&list,2);
    SequentialListSet(&list,3,60);
    for(int i=0;i<SequentialListSize(&list);i++){
        printf("%d %d\n",i,SequentialListIndex(&list,i));
    }
  
    return 0;  
}