数据结构之顺序表

目录

1. 顺序表是什么？

2. 顺序表的接口实现

1. 尾插

2. 头插

3. 尾删

4. 头删

5. 打印

6. 任意位置插入

7. 任意位置删除

8. 查询

3. 顺序表实现结果界面

*****************************************************************************************************

一、顺序表是什么？

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。

顺序表一般可以分为： 1. 静态顺序表：使用定长数组存储。

#define N 100
typedef int SQDataType;
typedef struct SeqList
{
SLDataType array[N]; // 定长数组
size_t size; // 有效数据的个数
}SL;

2. 动态顺序表：使用动态开辟的数组存储。

typedef int SQDataType;
typedef struct SeqList {
    SQDataType* a;// 指向动态开辟的数组
    int size;//有效数据个数
    int capacity;//判断容量，满了就扩容
    
}SL;

二、顺序表的接口实现

头文件:建立一个SeqList.h的头文件，代码如下：

#pragma once
#include<stdio.h>
#include<string.h>
#include<malloc.h>
#include<stdlib.h>
#include<assert.h>

//动态版
typedef int SQDataType;
typedef struct SeqList {
    SQDataType* a;
    int size;//有效数据个数
    int capacity;//判断容量，满了就扩容
    
}SL;
//增删查改操作接口函数
void SqListInit(SL* ps);//初始化
void SqListPrint(SL* ps);
void SeqListPushBack(SL* ps,SQDataType x);//尾插
void SeqListPushFront(SL* ps, SQDataType x);//头插
void SeqListPopBack(SL* ps);//尾删
void SeqListPopFront(SL* ps);//头删
void checkcacpcity(SL* ps);
void SeqListInsert(SL* ps, int pos, SQDataType x);//任意位置插入
void SeqListErase(SL* ps, int pos);//任意位置删除
void SeqListDestory(SL* ps);
int SeqListFind(SL* ps, SQDataType x);//查找
int SeqListModity(SL* ps, int pos,SQDataType x);//修改

建立一个SeqList.c的文件实现接口函数，代码如下:

#include "SeqList.h"
void SqListInit(SL* ps)
{
    ps->a = NULL;
    ps->size = 0;
    ps->capacity = 0;
}
void SqListPrint(SL* ps) {
    for(int i = 0;i<ps->size;i++){
        printf("%d ", ps->a[i]);

    }
    printf("\n");
}
void checkcacpcity(SL* ps)
{
    if (ps->size == ps->capacity) {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));
        if (tmp == NULL) {
            printf("realloc fail\n");
            exit(-1);
        }
        else
        {
            ps->a = tmp;
            ps->capacity = newcapacity;

        }
    }
}
void SeqListPushBack(SL* ps, SQDataType x)
{
    checkcacpcity(ps);
    
    ps->a[ps->size] = x;
    ps->size++;
}
void SeqListPushFront(SL* ps, SQDataType x)
{
    checkcacpcity(ps);
    int end = ps->size - 1;
    while (end >= 0) {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[0] = x;
    ps->size++;
}
void SeqListPopBack(SL* ps)
{
    assert(ps->size > 0);
    ps->size--;
}//尾删
void SeqListPopFront(SL* ps) {
    assert(ps->size > 0);
    int start = 1;
    while (start < ps->size)
    {
        ps->a[start - 1] = ps->a[start];
        start++;
    }
    ps->size--;


}//头删


void SeqListInsert(SL* ps, int pos, SQDataType x) 
{
    assert(pos < ps->size);
    checkcacpcity(ps);
    int end = ps->size - 1;
    while (end >= pos)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[pos] = x;
    ps->size++;

}//任意位置插入
void SeqListErase(SL* ps, int pos)
{
    assert(pos < ps->size);
    int start = pos + 1;
    while (start < ps->size)
    {
        ps->a[start - 1] = ps->a[start];
        start++;
    }
    ps->size--;

}
//任意位置删除

int SeqListFind(SL* ps, SQDataType x)
{
    for (int i = 0; i < ps->size; i++) {
        if (ps->a[i] == x) {
            return i;
        }

    }
    return -1;
}
int SeqListModity(SL* ps, int pos, SQDataType x)
{
    assert(pos < ps->size);
    ps->a[pos] = x;
}

void SeqListDestory(SL* ps)
{
    free(ps->a);
    ps->a = NULL;
    ps->size = ps->capacity = 0;
}

初始化

开始初始化，我们既可以用a指向malloc开辟的一个空间，也可以直接将a指向NULL，在后面在进行开辟，这里采用第二种方式。

void SqListInit(SL* ps)
{
    ps->a = NULL;
    ps->size = 0;
    ps->capacity = 0;
}

检查是否需要扩容

当size与capacity相等时，说明容量满了，需要扩容，我们使用realloc开辟一块空间。需要注意的是因为在初始化时我们将size和capacity的值置为空，因此我们需要将capacity的值设置为非0，这里我用三目运算符将其设置为4。

void checkcacpcity(SL* ps)
{
    if (ps->size == ps->capacity) {
        int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
        SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));
        if (tmp == NULL) {
            printf("realloc fail\n");
            exit(-1);
        }
        else
        {
            ps->a = tmp;
            ps->capacity = newcapacity;

        }
    }
}

1. 尾插

代码如下：

void SeqListPushBack(SL* ps, SQDataType x)
{
    checkcacpcity(ps);
    
    ps->a[ps->size] = x;
    ps->size++;
}

2. 头插

头插不能在顺序表的头部插入，只能把所有的数据往后挪，再把数据插入。

问题就是需要拿几次，和在存放时的越界问题，但这里应该不会出现这种问题，当size和capacity的值相等的时候就会扩容

代码如下

void SeqListPushFront(SL* ps, SQDataType x)
{
    checkcacpcity(ps);
    int end = ps->size - 1;
    while (end >= 0) {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[0] = x;
    ps->size++;
}

3. 尾删

尾删实现起来超级简单，不过得检查一下size，这种assert的方法比较“暴力”，但感觉方便。

void SeqListPopBack(SL* ps)
{
    assert(ps->size > 0);
    ps->size--;
}//尾删

4. 头删

因为顺序表是连续存储的，所以头删时要依次挪动数据

void SeqListPopFront(SL* ps) {
    assert(ps->size > 0);
    int start = 1;
    while (start < ps->size)
    {
        ps->a[start - 1] = ps->a[start];
        start++;
    }
    ps->size--;


}//头删

5. 打印

打印就是常规方法，依次遍历，然后输出。

void SqListPrint(SL* ps) {
    for(int i = 0;i<ps->size;i++){
        printf("%d ", ps->a[i]);

    }
    printf("\n");
}

6. 任意位置插入

任意位置插入，我们通过下标找到需要插入的位置，然后将x插入其中。

void SeqListInsert(SL* ps, int pos, SQDataType x) 
{
    assert(pos < ps->size);
    checkcacpcity(ps);
    int end = ps->size - 1;
    while (end >= pos)
    {
        ps->a[end + 1] = ps->a[end];
        end--;
    }
    ps->a[pos] = x;
    ps->size++;

}

7. 任意位置删除

任意位置删除，同上也是通过下标找到需要删除的数据，然后从下一位开始一个一个从后往前覆盖。

void SeqListErase(SL* ps, int pos)
{
    assert(pos < ps->size);
    int start = pos + 1;
    while (start < ps->size)
    {
        ps->a[start - 1] = ps->a[start];
        start++;
    }
    ps->size--;

}

8. 查询

通过遍历来查找所需的元素，如果找到则返回元素的下标，否则返回-1表示不存在。

int SeqListFind(SL* ps, SQDataType x)
{
    for (int i = 0; i < ps->size; i++) {
        if (ps->a[i] == x) {
            return i;
        }

    }
    return -1;
}

三、顺序表实现结果界面

结果界面实现（只实现了一部分，其余操作一样，由于时间关系，省略其他操作），代码如下：

#include "SeqList.h"
//测试函数1
void TestSeqList() {
    SL sl;
    SqListInit(&sl);
    SeqListPushBack(&sl, 1);
    SeqListPushBack(&sl, 2);
    SeqListPushBack(&sl, 3);
    SeqListPushBack(&sl, 4);
    
    
    SqListPrint(&sl);


}
//测试函数2
void TestSeqList2() {

    SL sl;
    SqListInit(&sl);
    SeqListPushFront(&sl, 5);
    SeqListPushFront(&sl, 6);
    SeqListPushFront(&sl, 7);
    SeqListPushFront(&sl, 5);
    SeqListPushFront(&sl, 6);
    SeqListPushFront(&sl, 7);
    SeqListPushFront(&sl, 5);
    SeqListPushFront(&sl, 6);
    SeqListPushFront(&sl, 7);
    SqListPrint(&sl);
    SeqListPopBack(&sl);
    SeqListPopBack(&sl);
    SqListPrint(&sl);
    SeqListPopFront(&sl);
    SqListPrint(&sl);

}
//测试函数3
void TestSeqList3() {
    SL sl;
    SqListInit(&sl);
    SeqListPushBack(&sl, 1);
    SeqListPushBack(&sl, 2);
    SeqListPushBack(&sl, 3);
    SeqListPushBack(&sl, 4);
    SqListPrint(&sl);
    SeqListInsert(&sl, 1, 20);

    SqListPrint(&sl);
    SeqListErase(&sl, 1);
    SqListPrint(&sl);
    SeqListDestory(&sl);


}
//菜单
void menu()
{
    printf("*****************************\n");
    printf("1.尾插数据， 2.头插数据\n");
    printf("3.尾删数据， 4.头删数据\n");
    printf("5.打印数据， -1.退出数据\n");
    printf("*****************************\n");
    printf("请输入你的操作选项：");

}

int main(void)
{
    SL sl;
    SqListInit(&sl);
    int option = 0;
    int x = 0;
    while (option != -1)
    {

        
        menu();
        scanf_s("%d", &option);
        switch (option)
        {
        case 1:
            printf("请输入要插入的数据，以-1结束！\n");
            do
            {
                scanf_s("%d", &x);
                if (x != -1)
                {
                    SeqListPushBack(&sl, x);
                }
            } while (x != -1);
            break;


        case 2:

        case 3:

        case 4:


        case 5:
            SqListPrint(&sl);
            break;



        default:
            break;
        }
    }
    SeqListDestory(&sl);
    return 0;

}