c语言数据结构入门——顺序表

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

例如：本节是数据结构的入门，跟着我一起来攻克顺序表吧

---

一、什么是数据结构？

概念：数据结构是计算机存储、组织数据的⽅式。
最基础的数据结构：数组。

二、顺序表

2.1 概念

先介绍一下线性表的概念：
线性表（linear list）是n个具有相同特性的数据元素的有限序列。（通俗来说是指具有相同特性的一类数据结构的统称——在逻辑结构上一定是线性的，在物理结构（内存存储上）不一定是线性的）
顺序表：顺序表的底层结构是数组，所以顺序表在逻辑结构上是线性的，在物理结构上也是线性的
• 顺序表和数组的区别：
顺序表的底层结构是数组，对数组的封装，实现了常⽤的增删改查等接⼝

2.2 顺序表的分类

1.静态顺序表

struct Seqlist
{
	int a[100];
	int size;//有效数据个数
};

静态顺序表缺陷：空间给少了不够⽤，给多了造成空间浪费

2.动态顺序表

struct Seqlist
{
	int *a;
	int size;//有效数据个数
	int capacity;//空间大小
};

三、动态顺序表的实现

头文件 Seqlist.h

#pragma once
#include <stdio.h>//(.h文件主要是结构的实现和声明，函数的声明）
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
//动态顺序表
typedef int SLDataType;//对结构体数据类型进行重命名方便后续修改数据类型
typedef struct Seqlist
{
	SLDataType* a;
	int size;//有效数据个数
	int capacity;//空间大小
}SL;//对结构体进行重命名方便使用
//对顺序表进行初始化
void SLInit(SL *s);
//顺序表的销毁
void SLDestroy(SL* s);
//头部/尾部 插入/删除 
void SLPushBack(SL*ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);
void SLPrint(SL* ps);
bool SLIsEmpty(SL* ps);
void SLInsert(SL* ps, int pos, SLDataType x);//在指定位置之前插入数据
void SLErase(SL* ps, int pos);//删除指定位置的数据
bool SLFind(SL* ps, SLDataType x);//查找

顺序表接口的实现 Seqlist.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Seqlist.h"
void SLInit(SL *s)
{
	s->a = NULL;
	s->size = s->capacity = 0;
}
void SLDestroy(SL* s)
{
	if(s->a)//free之前要先判断是否为空
		free(s->a);
	s->a = NULL;
	s->size = s->capacity = 0;
}
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{	//空间不足以再额外插入一个数据
		//用realloc扩容，注意第二个参数的写法用sizeof来知道要扩容多少个字节,通常以2倍来扩容 
		//用中间变量来接受，如果直接用ps->a来接受，万一realloc开辟空间失败，里面的数据全都消失了
		int newCapcity = ps->capacity == 0 ? 4 : 2 * ps->capacity;//因为capacity是0时，对它进行*2还是0，用一个新变量进行三目运行符操作
		//当三目操作符第一个表达式为真则输出4，为假则输出第三个表达式
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapcity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail\n");
			return 1;
		}
		ps->a = tmp;
		ps->capacity = newCapcity;
	}
}
//尾插函数
void SLPushBack(SL* ps, SLDataType x)
{
	/*思想：1.判断顺序表是否有足够的空间
			1）有足够的空间就可以直接插入 ps->a[ps->size]插入数据就可以了
			2）空间不够，需要扩容，扩容怎么扩？申请但是个空间？(通常以2倍或1.5倍进行扩容)*/
	assert(ps);
	//判断空间
	SLCheckCapacity(ps);
	//直接插入数据
	ps->a[ps->size] = x;
	ps->size++;
}
//头插函数
void SLPushFront(SL* ps, SLDataType x)
{
	/*思想：
	1\判断空间是否足够
	1）空间不够，扩容
	2）空间足够，历史数据后移一位
	*/
	assert(ps);
	//判断空间是否足够，不够则扩容
	SLCheckCapacity(ps);
	//空间足够，历史数据后移一位
	//从后往前
	for (size_t i = ps->size; i >0; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[0] = x;
	ps->size++;
}

//尾删
void SLPopBack(SL* ps)
{	//要先判断顺序表是否为空，为空不能进行删除操作
	assert(ps);
	assert(!SLIsEmpty(ps));
	ps->size--;
}
void SLPopFront(SL* ps)
{
	//直接从后往前覆盖
	assert(ps);
	assert(!SLIsEmpty(ps));
	for (size_t i = 0; i < ps->size-1; i++)
	{
		ps->a[i] = ps->a[i+1];
	}
	ps->size--;

}
void SLPrint(SL* ps)
{
	for (size_t i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
bool SLIsEmpty(SL* ps)//判断顺序表是否为空
{
	assert(ps);
	return ps->size == 0;
}
//在指定位置之前插入数据，有了在指定位置之前插入数据之后，就可以在头插尾插接口中直接调用即可
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	//不要忘了对pos加以限制
	assert(pos >= 0 && pos <= ps->size);
	//扩容
	SLCheckCapacity(ps);
	//把pos位置级以后的数据往后挪动一位
	//循环条件里的i的初始值是size还是size-1都是可以的，但不同的初始值对应不同的约束条件
	//可以通过代入边界情况的来确定约束条件
	/*for (size_t i = ps->size; i >pos; i--)
	{
		//最后一次进来是pos+1
		ps->a[i] = ps->a[i + 1];//pos->a[pos+1]=ps->a[pos];
	}*/
	for (size_t i = ps->size-1; i > pos-1; i--)
	{
		//最后进来的是pos
		ps->a[i+1] = ps->a[i];//ps->a[pos+1]=ps->a[pos]
	}
	ps->a[pos] = x;
	ps->size++;
}
//删除指定位置的数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(!SLIsEmpty(ps));
	assert(pos >= 0 && pos <= ps->size);
	for (int i = pos; i < ps->size-1; i++)
	{
		ps ->a[i] = ps -> a[i + 1];
	}
	ps->size--;
}
bool SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size ; i++)
	{
		if (ps->a[i] == x)
		{
			return true;
		}
	}
	return false;
}

测试文件 test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Seqlist.h"
void SLtest()
{
	SL sl;
	SLInit(&sl);
	//顺序表的具体操作
	//尾插
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);//1 2 3 4
	SLPrint(&sl);
	//头插
	SLPushFront(&sl, 5);//5 1 2 3 4
	SLPushFront(&sl, 6);//6 5 1 2 3 4
	SLPushFront(&sl, 7);//7 6 5 1 2 3 4
	SLPrint(&sl);
	//尾删
	SLPopBack(&sl);
	SLPrint(&sl);
	SLPopBack(&sl);
	SLPrint(&sl);
	SLDestroy(&sl);
}
void SLtest02()
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4);//1 2 3 4
	SLPrint(&sl);
	头删
	//SLPopFront(&sl);
	//SLPrint(&sl);
	//SLPopFront(&sl);
	//SLPrint(&sl);
	//SLDestroy(&sl);
	在指定位置之前插入数据
	//SLInsert(&sl, 2, 2);
	//在指定位置删除数据
	SLErase(&sl, 0);
	SLPrint(&sl);
	SLErase(&sl,sl.size-1);
	SLPrint(&sl);
	SLDestroy(&sl);
}
int main()
{
	//SLtest();
	SLtest02();
	return 0;
}

总结

本节学习了数据结构的入门，顺序表的代码量还是挺大的需要自己好好的钻研