目录
1.什么是数据结构
概念：数据结构是计算机存储、组织数据的⽅式。数据结构是指相互之间存在⼀种或多种特定关系的数据元素的集合。数据结构反映数据的内部构成，即数据由那部分构成，以什么⽅式构成，以及数据元素之间呈现的结构。
最基础的数据结构：数组。
2.顺序表
2.1顺序表的概念及结构
2.1.1线性表
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是⼀种在实际中⼴泛使⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串...
线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
2.2顺序表分类
顺序表的底层结构是数组，对数组的封装，实现了常用的增删查改等接口。
2.2.1静态顺序表
概念：使用定长数组存储元素
缺陷：空间给少了不够用，给多了造成空间浪费。
2.2.2动态顺序表
动态顺序表可以按需申请空间。接下来主要实现动态顺序表。
3.动态顺序表的实现
3.1头文件SeqList.h
首先是头文件SeqList.h,声明一些会使用到的变量和增删查改的接口函数。在顺序表结构中，size表示的是已经存储到数组中有效数据的个数，size的大小等于对应有效数据个数的下标+1，size-1是最后一个有效数据的下标，capacity是当前开辟的容量大小。
//SeqList.h 该注释说明这段代码在SeqList.h这个文件中
#pragma once
#define INIT_CAPACITY 4 //定义扩容的初始值
typedef int SLDataType; //给需要存储的数据类型进行重命名
// 动态顺序表 -- 按需申请，下列是顺序表的结构
typedef struct SeqList
{
SLDataType* a; //指向存储空间的指针，也可以说是a数组
int size; // 有效数据个数，size的大小对应着有效数据个数的下标+1
int capacity; // 空间容量，空间容量是当前开辟了多大容量空间
}SL;
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps); //遍历打印有效数据
//扩容
void SLCheckCapacity(SL* ps); //动态扩容函数
//头部插⼊删除 / 尾部插⼊删除
void SLPushBack(SL* ps, SLDataType x); //尾插
void SLPopBack(SL* ps); //尾删
void SLPushFront(SL* ps, SLDataType x); //头插
void SLPopFront(SL* ps); //头删
//指定位置之前插⼊/删除数据
void SLInsert(SL* ps, int pos, SLDataType x); //指定位置之前插入数据
void SLErase(SL* ps, int pos); //删除指定位置的数据
int SLFind(SL* ps, SLDataType x); //查找指定位置的数据3.2 主要功能实现文件SeqList.c
3.2.1初始化和销毁
3.2.1.1初始化
函数实现：
void SLInit(SL* ps)
{
ps->a = NULL;
ps->size = 0;
ps->capacity = 0;
}将指向的数组的指针a置为NULL，有效数据个数和空间大小置为0.
测试代码在test.c文件中
#include "SeqList.h"
void test()
{
SL s; //创建一个顺序表的结构体变量
SLInit(&s);
}
int main()
{
test();
return 0;
}
3.2.1.2销毁
函数实现：
void SLDestroy(SL* ps)
{
//销毁数组，然后将顺序表初始化
if (ps->a)
{
free(ps->a);
}
ps->a = NULL;
ps->size = 0;
ps->capacity = 0;
} 尾插一个数据“1”，经过调试显示：
通过打印函数在终端的显示：
通过销毁函数之后调试显示如下：
测试代码：
#include "SeqList.h"
void test()
{
SL s; //创建一个顺序表的结构体变量
SLInit(&s);
SLPushBack(&s, 1);
SLPrint(&s);
SLDestroy(&s);
}
int main()
{
test();
return 0;
}3.2.1.3打印函数
函数实现：
void SLPrint(SL* ps) //遍历打印有效数据
{
assert(ps);
//依次遍历访问数组
for (int i = 0; i < ps->size; i++)
{
printf("%d ", ps->a[i]);
}
printf("\n");
}3.2.2尾部插入删除和头部插入删除
3.2.2.1尾插
函数实现：
//扩容
void SLCheckCapacity(SL* ps) //动态扩容函数
{
//判断是否需要扩容 通过size和capacity是否相等进行判断
if (ps->size == ps->capacity)
{
//求出新的容量大小，如果capacity为0，初始为4，如果不为0，则扩充到原来的两倍
int newcapacity = ps->capacity == 0 ? INIT_CAPACITY : ps->capacity * 2;
//需要扩容，先用一个临时变量接收创建的空间，判断创建好之后在赋值给ps->a
SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
if (tmp == NULL)
{
perror("realloc fail!\n");
exit(1);
}
ps->a = tmp;
ps->capacity = newcapacity;
}
}
void SLPushBack(SL* ps, SLDataType x) //尾插
{
//先判断是否为有效顺序表
assert(ps);
SLCheckCapacity(ps);
//尾插，在数组的后面插入数据
ps->a[ps->size] = x; //把x放入ps->size位置
ps->size++; //因为增加了一个数据，所以size+1
}测试代码：
#include "SeqList.h"
void test()
{
SL s; //创建一个顺序表的结构体变量
SLInit(&s);
SLPushBack(&s, 1);
SLPushBack(&s, 2);
SLPushBack(&s, 3);
SLPushBack(&s, 4);
SLPrint(&s);
SLDestroy(&s);
}
int main()
{
test();
return 0;
}
3.2.2.2头插
函数实现：
void SLPushFront(SL* ps, SLDataType x) //头插
{
assert(ps);
//先判断是否需要扩容
SLCheckCapacity(ps);
//先将已有的数据向后挪动一位
for (int i = ps->size; i > 0; i--)
{
ps->a[i] = ps->a[i - 1];
}
//将数据插入第一个位置
ps->a[0] = x;
ps->size++;
}测试代码：
#include "SeqList.h"
void test()
{
SL s; //创建一个顺序表的结构体变量
SLInit(&s); //初始化
SLPushBack(&s, 1); //尾插
SLPushBack(&s, 2);
SLPushBack(&s, 3);
SLPushBack(&s, 4);
SLPushFront(&s, 7); //头插
SLPushFront(&s, 8);
SLPrint(&s); //打印
SLDestroy(&s); //销毁
}
int main()
{
test();
return 0;
}
3.2.2.3尾删
函数实现：
void SLPopBack(SL* ps) //尾删
{
assert(ps);
assert(ps->size != 0); //有效个数不能为0
//删除最后一个元素就是把size的大小减去1
ps->size -= 1;
}测试代码：
void test()
{
SL s; //创建一个顺序表的结构体变量
SLInit(&s); //初始化
SLPushBack(&s, 1); //尾插
SLPushBack(&s, 2);
SLPushBack(&s, 3);
SLPushBack(&s, 4);
//SLPushFront(&s, 7); //头插
//SLPushFront(&s, 8);
SLPopBack(&s); //尾删
SLPopBack(&s);
SLPopBack(&s);
SLPrint(&s); //打印
SLDestroy(&s); //销毁
}
int main()
{
test();
return 0;
}
3.2.2.4头删
函数实现：
void SLPopFront(SL* ps) //头删
{
assert(ps);
assert(ps->size);
//从下标为1的位置将全部有效数据往前挪动一位
for (int i = 1; i < ps->size; i++)
{
ps->a[i - 1] = ps->a[i];
}
//size-1
ps->size -= 1;
}测试代码：
#include "SeqList.h"
void test()
{
SL s; //创建一个顺序表的结构体变量
SLInit(&s); //初始化
SLPushBack(&s, 1); //尾插
SLPushBack(&s, 2);
SLPushBack(&s, 3);
SLPushBack(&s, 4);
//SLPushFront(&s, 7); //头插
//SLPushFront(&s, 8);
//SLPopBack(&s); //尾删
//SLPopBack(&s);
//SLPopBack(&s);
SLPopFront(&s);
SLPopFront(&s);
SLPrint(&s); //打印
SLDestroy(&s); //销毁
}
int main()
{
test();
return 0;
}
3.2.3指定位置之前插入数据，指定位置删除和查找数据
指定的位置为数组的下标位置。
3.2.3.1指定位置之前插入数据
函数实现：
void SLInsert(SL* ps, int pos, SLDataType x) //指定位置之前插入数据
{
assert(ps);
assert(pos <= ps->size && pos >= 0);
//先判断是否需要扩容
SLCheckCapacity(ps);
//将pos及之后的数据向后挪动一位
for (int i = ps->size; i > pos; i--)
{
ps->a[i] = ps->a[i - 1];
}
//在pos这个位置插入数据
ps->a[pos] = x;
ps->size++;
}测试代码：
#include "SeqList.h"
void test()
{
SL s; //创建一个顺序表的结构体变量
SLInit(&s); //初始化
SLPushBack(&s, 1); //尾插
SLPushBack(&s, 2);
SLPushBack(&s, 3);
SLPushBack(&s, 4);
//SLPushFront(&s, 7); //头插
//SLPushFront(&s, 8);
//SLPopBack(&s); //尾删
//SLPopBack(&s);
//SLPopBack(&s);
//SLPopFront(&s);
//SLPopFront(&s);
SLInsert(&s, 0, 7);
SLPrint(&s); //打印
SLDestroy(&s); //销毁
}
int main()
{
test();
return 0;
}
3.2.3.2删除指定位置数据
函数实现：
void SLErase(SL* ps, int pos) //删除指定位置的数据
{
assert(ps);
assert(pos >= 0 && pos < ps->size);
//将pos后面的数据全部往前挪动一位
for (int i = pos; i < ps->size - 1; i++)
{
ps->a[i] = ps->a[i + 1];
}
ps->size--;
}测试代码：
#include "SeqList.h"
void test()
{
SL s; //创建一个顺序表的结构体变量
SLInit(&s); //初始化
SLPushBack(&s, 1); //尾插
SLPushBack(&s, 2);
SLPushBack(&s, 3);
SLPushBack(&s, 4);
//SLPushFront(&s, 7); //头插
//SLPushFront(&s, 8);
//SLPopBack(&s); //尾删
//SLPopBack(&s);
//SLPopBack(&s);
//SLPopFront(&s);
//SLPopFront(&s);
//SLInsert(&s, 0, 7); //指定位置之前插入
SLErase(&s, 1); //删除指定位置的数据
SLPrint(&s); //打印
SLDestroy(&s); //销毁
}
int main()
{
test();
return 0;
}
3.2.3.3查找数据
在顺序表中查找数据，如果找到了返回下标，如果没找到在终端显示没找到。
函数实现：
int SLFind(SL* ps, SLDataType x) //查找数据
{
assert(ps);
for (int i = 0; i < ps->size; i++)
{
if (ps->a[i] == x)
{
return i;
}
}
return -1;
}测试代码：
#include "SeqList.h"
void test()
{
SL s; //创建一个顺序表的结构体变量
SLInit(&s); //初始化
SLPushBack(&s, 1); //尾插
SLPushBack(&s, 2);
SLPushBack(&s, 3);
SLPushBack(&s, 4);
//SLPushFront(&s, 7); //头插
//SLPushFront(&s, 8);
//SLPopBack(&s); //尾删
//SLPopBack(&s);
//SLPopBack(&s);
//SLPopFront(&s);
//SLPopFront(&s);
//SLInsert(&s, 0, 7); //指定位置之前插入
//SLErase(&s, 1); //删除指定位置的数据
SLPrint(&s); //打印
int ret = SLFind(&s, 5);
if (ret == -1)
{
printf("没找到!\n");
}
else
{
printf("找到了， 下标是:%d\n", ret);
}
SLDestroy(&s); //销毁
}
int main()
{
test();
return 0;
}通过函数在顺序表中查找“5”：
将查找“5”换成查找“3”：
3.3参考代码
//SeqList.h 该注释说明这段代码在SeqList.h这个文件中
#pragma once
#define INIT_CAPACITY 4 //定义扩容的初始值
typedef int SLDataType; //给需要存储的数据类型进行重命名
// 动态顺序表 -- 按需申请，下列是顺序表的结构
typedef struct SeqList
{
SLDataType* a; //指向存储空间的指针，也可以说是a数组
int size; // 有效数据个数
int capacity; // 空间容量
}SL;
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps); //遍历打印有效数据
//扩容
void SLCheckCapacity(SL* ps); //动态扩容函数
//头部插⼊删除 / 尾部插⼊删除
void SLPushBack(SL* ps, SLDataType x); //尾插
void SLPopBack(SL* ps); //尾删
void SLPushFront(SL* ps, SLDataType x); //头插
void SLPopFront(SL* ps); //头删
//指定位置之前插⼊/删除数据
void SLInsert(SL* ps, int pos, SLDataType x); //指定位置之前插入数据
void SLErase(SL* ps, int pos); //删除指定位置的数据
int SLFind(SL* ps, SLDataType x); //查找数据//SeqList.c
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include "SeqList.h"
//初始化和销毁
void SLInit(SL* ps)
{
ps->a = NULL;
ps->size = 0;
ps->capacity = 0;
}
void SLDestroy(SL* ps)
{
//销毁数组，然后将顺序表初始化
if (ps->a)
{
free(ps->a);
}
ps->a = NULL;
ps->size = 0;
ps->capacity = 0;
}
void SLPrint(SL* ps) //遍历打印有效数据
{
assert(ps);
//依次遍历访问数组
for (int i = 0; i < ps->size; i++)
{
printf("%d ", ps->a[i]);
}
printf("\n");
}
//扩容
void SLCheckCapacity(SL* ps) //动态扩容函数
{
//判断是否需要扩容 通过size和capacity是否相等进行判断
if (ps->size == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? INIT_CAPACITY : ps->capacity * 2;
//需要扩容
SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));
if (tmp == NULL)
{
perror("realloc fail!\n");
exit(1);
}
ps->a = tmp;
ps->capacity = newcapacity;
}
}
//头部插⼊删除 / 尾部插⼊删除
void SLPushBack(SL* ps, SLDataType x) //尾插
{
//先判断是否为有效顺序表
assert(ps);
SLCheckCapacity(ps);
//尾插，在数组的后面插入数据
ps->a[ps->size] = x;
ps->size++;
}
void SLPopBack(SL* ps) //尾删
{
assert(ps);
assert(ps->size != 0);
//删除最后一个元素就是把size的大小减去1
ps->size -= 1;
}
void SLPushFront(SL* ps, SLDataType x) //头插
{
assert(ps);
//先判断是否需要扩容
SLCheckCapacity(ps);
//先将已有的数据向后挪动一位
for (int i = ps->size; i > 0; i--)
{
ps->a[i] = ps->a[i - 1];
}
//将数据插入第一个位置
ps->a[0] = x;
ps->size++;
}
void SLPopFront(SL* ps) //头删
{
assert(ps);
assert(ps->size);
//从下标为1的位置将全部有效数据往前挪动一位
for (int i = 1; i < ps->size; i++)
{
ps->a[i - 1] = ps->a[i];
}
//size-1
ps->size -= 1;
}
//指定位置之前插⼊/删除数据
void SLInsert(SL* ps, int pos, SLDataType x) //指定位置之前插入数据
{
assert(ps);
assert(pos <= ps->size && pos >= 0);
//先判断是否需要扩容
SLCheckCapacity(ps);
//将pos及之后的数据向后挪动一位
for (int i = ps->size; i > pos; i--)
{
ps->a[i] = ps->a[i - 1];
}
//在pos这个位置插入数据
ps->a[pos] = x;
ps->size++;
}
void SLErase(SL* ps, int pos) //删除指定位置的数据
{
assert(ps);
assert(pos >= 0 && pos < ps->size);
//将pos后面的数据全部往前挪动一位
for (int i = pos; i < ps->size - 1; i++)
{
ps->a[i] = ps->a[i + 1];
}
ps->size--;
}
int SLFind(SL* ps, SLDataType x) //查找指定位置的数据
{
assert(ps);
for (int i = 0; i < ps->size; i++)
{
if (ps->a[i] == x)
{
return i;
}
}
return -1;
}//test.c
#include "SeqList.h"
void test()
{
SL s; //创建一个顺序表的结构体变量
SLInit(&s); //初始化
SLPushBack(&s, 1); //尾插
SLPushBack(&s, 2);
SLPushBack(&s, 3);
SLPushBack(&s, 4);
//SLPushFront(&s, 7); //头插
//SLPushFront(&s, 8);
//SLPopBack(&s); //尾删
//SLPopBack(&s);
//SLPopBack(&s);
//SLPopFront(&s);
//SLPopFront(&s);
//SLInsert(&s, 0, 7); //指定位置之前插入
//SLErase(&s, 1); //删除指定位置的数据
SLPrint(&s); //打印
int ret = SLFind(&s, 3);
if (ret == -1)
{
printf("没找到!\n");
}
else
{
printf("找到了， 下标是:%d\n", ret);
}
SLDestroy(&s); //销毁
}
int main()
{
test();
return 0;
}
扫一扫
2414
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
