顺序表学习笔记（基础）

 属于线性表旗下的一种，所以专门存储 one-to-one 关系的数据。

顺序表提供的具体实现方案是：将数据全部存储到一整块内存空间中，数据元素之间按照次序挨个存放。（类似数组）

顺序表中除了存储数据本身的值外，而一般提供了以下数据：

• 顺序表的最大存储容量：即顺序表最多可以存储的数据量
• 顺序表的长度：目前顺序表中存储的数据个数

#include 
#include 

#define MAXSIZE 5 //对MAXSIZE进行宏定义，表示顺序表的最大容量

/*结构体*/
typedef struct {
    int* head; //利用指针定义一个长度不确定的“数组”（动态数组）
    int length; //记录顺序表的长度
    int size; //记录顺序表的存储容量
}SeqList;
/*初始化*/
void init(SeqList* sl) 
{
    //构造一个空的顺序表，动态申请存储空间
    sl->head = (int*)malloc(MAXSIZE * sizeof(int)); //初始化head数组
    //如果申请失败，作出提示并直接退出程序
    if (!sl->head) //判断head数组是否完成初始化
    {
        printf("初始化失败\n");
        exit(0);
    }
    sl->length = 0;
    //空表的长度初始化为0
    sl->size = MAXSIZE;
    //空表的初始存储空间为MAXSIZE
}
/*判空*/
int empty(SeqList* sl)
{
    if (sl->length == 0)
        return 1;
    else
        return 0;
}
/*长度*/
int length(SeqList* sl)
{
    return sl->length;
}
/*建立*/
int creat(SeqList* sl, int creat[], int extent) //顺序表，数组，长度
{
    if (extent > MAXSIZE)
    {
        printf("空间不够\n");
        return 0;
    }
    for (int i = 0; i < extent; i++)
    {
        sl->head[i] = creat[i];
    }
    sl->length = extent;
    return 1;
}
/*插入*/
int insert(SeqList* sl, int index, int value) //顺序表，索引，插入值
{
    if (sl->length == MAXSIZE)
    {
        printf("上溢出错误\n");
        return 0;
    }
    if (index < 1 || index > sl->length + 1)
    {
        printf("插入位置错误（从1开始）\n");
        return 0;
    }
    for (int i = sl->length; i >= index; i--)
    {
        sl->head[i] = sl->head[i - 1];
    }
    sl->head[index - 1] = value;
    sl->length++;
    return 1;
}
/*删除*/
int delete(SeqList* sl, int index, int value) //顺序表，索引，删除值
{
    if (sl->length == 0)
    {
        printf("发生下溢错误\n");
        return 0;
    }
    if (index > sl->length || index < 1)
    {
        printf("删除位置错误\n");
        return 0;
    }
    value = sl->head[index - 1]; //把要删除的数据返回
    for (int i = index; i <= sl->length; i++)
    {
        sl->head[i - 1] = sl->head[i];
    }
    sl->length--;
    return 1;
}
/*修改*/
int set(SeqList* sl, int index, int value)
{
    if (index < 1 || index > sl->length)
    {
        printf("修改位置错误\n");
        return 0;
    }
    sl->head[index-1] = value;
    return 1;
}
/*位查找*/
int get(SeqList* sl, int index, int* result)
{
    if (index < 1 || index > sl->length)
    {
        printf("查找位置错误\n");
        return 0;
    }
    else
    {
        *result = sl->head[index - 1];
        return 1;
    }
}
/*值查找（查出返回索引值）*/
int locate(SeqList* sl, int value) 
{
    for (int i = 0; i < sl->length; i++)
    {
        if (sl->head[i] == value)
        {
            return i + 1;
        }
    }
    return 0;
}
/*输出*/
void display(SeqList* sl)
{
    for (int i = 0; i < sl->length; i++) 
    {
        printf("%d", sl->head[i]);
        //if (i == sl->length - 1){printf("%d", sl->head[i]);}
        //else{printf("%d，", sl->head[i]);}
    }
    printf("\n");
}
/*主函数*/
int main() {
    int value = 0;
    SeqList sl = { NULL, 0, 0 }; //属性初始化
    int data[] = { 1,2,3,4 }; //数据
    init(&sl); //初始化
    if (empty(&sl))
    {
        printf("目前顺序表为空，长度为：%d\n", length(&sl));
    }
    creat(&sl, data, 4); //建立
    printf("顺序表建立：");
    display(&sl); //测试建立（第一次输出）
    insert(&sl, 1, 0); //插入
    printf("顺序表中存储的元素分别是：\n"); //提示
    display(&sl); //测试插入
    delete(&sl, 1, value); //删除
    display(&sl); //测试删除
    set(&sl, 4, 0); //修改
    display(&sl); //测试修改
    int index = 1, sult = 0; //临时值sult
    get(&sl, index, &sult); //位查找
    printf("%d 索引值的位查找的数据值是：%d\n", index, sult); //输出位查找的值
    printf("%d 数据值的值查找的索引值是：%d\n", 0, locate(&sl, 0)); //输出值查找的值
    printf("尾插入：\n");
    insert(&sl, 5, 5); //尾插入
    display(&sl); //测试尾插入
    free(sl.head);//释放申请的堆内存
    system("pause"); //暂停黑窗口
    return 0;
}

顺序表和数组的关系及区别

顺序表 VS 数组

	顺序表（存储结构）	数组（数据类型）
区别	顺序表侧重表达了数据之间保持了 “一对一” 的逻辑关系	数组是顺序表在实际编程中的一种实现方式
相同	数据存储在一整块内存空间中，数据元素之间紧挨着存放