开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 数据结构与算法 -> 【数据结构入门】动图解顺序表，学会顺序表的增删查改，这一篇就够了 -> 正文阅读

[数据结构与算法]【数据结构入门】动图解顺序表，学会顺序表的增删查改，这一篇就够了

可以提前收藏以免以后找不到哟???

线性表基本介绍

线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear
list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。
线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点）

–参考自百度百科
而我们今天所讲述的也是较为简单的一种线性表 – 顺序表

顺序表的介绍（SeqList）

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

顺序表的功能

顺序表的结构（struct SeqList）

typedef int SLDateType;
//顺序表中的数据类型是可以随意的，可以是float，double，int 所以为了实现代码的维护性，我们可以在这里将类型定义为SLDateType，当我们后续需要修改时就只需要修改这一处！
typedef struct SeqList
{
	SLDateType* a;//数组指针，我们选择在堆上开空间，实现动态开辟版本
	size_t size;//顺序表的有效数据个数 —- 用int 也可以
	size_t capacity; // unsigned int，顺序表的容量 —- 用int 也可以
}SeqList;

顺序表的初始化（SeqListInit）

因为我们的test函数中传参的时候是通过结构体创建对象，传参的时候必须传指针才能修改我们我们在函数外部定义的对象
在这里插入图片描述

倘若我们没有传结构体指针的话，我们是无法修改外部的数据的，如下：
错误示范：

所以我们要注意结构体若需要传参的话，注意是否需要传指针！！！

void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

顺序表的尾插（SeqListPushBack）

在这里插入图片描述

顺序表的增加数据的时候需要考虑容量是否足够，我们的数据是从堆上开辟的，所以我们可以使用realloc这个接口当顺序表的有效数据已经和容量一样多的时候帮助我们重新开辟一块足够大的内存空间。并且在后面的学习中我们学到vector的迭代器的时候，就会用得到这里的知识，这里的扩容可能会导致迭代器的失效
下图演示的是capacity为3，size为2的时候插入两个数据的例子，这里我们扩容假设一次增加一个!!

根据上图我们就能知道我们需要插入数据的时候需要注意：是否有空间给我们放入。所以我们需要完成插入SeqListPushBack和 扩容CheckCapcity 这两个操作

代码如下（插入+扩容）：

//插入的逻辑-- 我们一般以2倍增，因为这样综合浪费的空间和开辟空间的时间消耗相对好些
void CheckCapcity(SeqList* ps)
{
	if (ps->capacity == ps->size)
	{
		size_t newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDateType* tmp = (SLDateType*)realloc(ps->a,sizeof(SLDateType)*(newcapacity));
		if (tmp == NULL)
		{
			printf("扩容失败，程序结束\n");
			exit(-1);
		}
		else
		{
		ps->a = tmp;
		ps->capacity = newcapacity;
		}
		
	}
}

void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	CheckCapcity(ps);//扩容的逻辑
	ps->a[ps->size] = x;
	ps->size++;
}

顺序表的任意位置插入（SeqListInsert）

分析，插入的时候需要检测是否空间足够，所以也会用上上面写的（CheckCapcity）接口
动图：以capacity为4，size为3的情况举例

void SeqListInsert(SeqList* ps, size_t pos, SLDateType x)
{
	assert(ps);
	assert(pos <= ps->size);
	CheckCapcity(ps);
	/* 1. 这里注意pos 和 end比较，int发生整型提升变成size_t
	int end = ps->size - 1;
	
	while ((int)pos <= end)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}*/
	// 2.这种就可以不用强转，都可以
	size_t end = ps->size;
	while (end > pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;

}

顺序表头插（SeqListPushFront）

头插的逻辑，细心的同学可以发现更任意位置插入类似，只需要将SeqListInsert中第二个参数pos设置成0，动图:可以看出，我们只需要复用SeqListInsert的逻辑就可以了

void SeqListPushFront(SeqList* ps, SLDateType x)
{
	SeqListInsert(ps, 0, x);
}

很多同学看完就会说，就这？ – 确实，就这

顺序表的任意位置删除（SeqListErase）

动图：以删除第一个位置为例
在这里插入图片描述

观察上图我们知道删除数据需要删除的位置必须是有效元素，我们在删除最后一个位置的时候可以直接将有效元素（size）-1的形式解决

void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	assert(pos < ps->size);
	size_t tmp = pos;
	while (tmp < ps->size)
	{
		ps->a[tmp] = ps->a[tmp + 1];
		tmp++;
	}
	ps->size--;
}

顺序表的头删（SeqListPopFront）

void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	size_t begin = 0;
	while (begin < ps->size-1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

顺序表的尾删（SeqListPopBack）

尾部删除元素时因为那个位置一定是存在元素的，即使你不初始化也是存在，只要我们不访问就可以了。- -函数栈帧相关的在之前有说，所以这个位置才将有效元素（size-1）就可以了！

void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	ps->size--;
}

顺序表的查找

顺序表只需要挨个遍历就可以了，找到了我们返回对应的下标，没找到返回-1

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

顺序表的销毁

我们的数组是动态开辟的，所以我们将数组释放，置成NULL

void SeqListDestory(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
}

全部代码

在这里插入图片描述

SeqList.h

// SeqList.h
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include<assert.h>

typedef int SLDateType;
typedef struct SeqList
{
	SLDateType* a;
	size_t size;
	size_t capacity; 
}SeqList;

// 增删查改 
void SeqListInit(SeqList* ps);
void SeqListDestory(SeqList* ps); 

void SeqListPrint(SeqList* ps);
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);
void SeqListPopBack(SeqList* ps);

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDateType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos);

SeqList.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
void CheckCapcity(SeqList* ps)
{
	if (ps->capacity == ps->size)
	{
		size_t newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDateType* tmp = (SLDateType*)realloc(ps->a,sizeof(SLDateType)*(newcapacity));
		if (tmp == NULL)
		{
			printf("扩容失败，程序结束\n");
			exit(-1);
		}
		else
		{
		ps->a = tmp;
		ps->capacity = newcapacity;
		}
		
	}
}
void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}
// 1.正常写法
//void SeqListPushBack(SeqList* ps, SLDateType x)
//{
//	assert(ps);
//	CheckCapcity(ps);
//	ps->a[ps->size] = x;
//	ps->size++;
//}

//2.复用Insrt
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	SeqListInsert(ps, ps->size, x);
}
void SeqListDestory(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
}
void SeqListPrint(SeqList* ps)
{
	for (int i = 0; i < (int)ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
//一般写法
//void SeqListPushFront(SeqList* ps, SLDateType x)
//{
//	assert(ps);
//	CheckCapcity(ps);
//	int end = ps->size - 1;
//	while (end >= 0)
//	{
//		ps->a[end + 1] = ps->a[end];
//		--end;
//	}
//	ps->a[0] = x;
//	++ps->size;
//}
//复用接口
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	SeqListInsert(ps, 0, x);
}
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	size_t begin = 0;
	while (begin < ps->size-1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	ps->size--;
}
int SeqListFind(SeqList* ps, SLDateType x)
{
	for (size_t i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
			return (int)i;
	}
	return -1;
}
void SeqListInsert(SeqList* ps, size_t pos, SLDateType x)
{
	assert(ps);
	assert(pos <= ps->size);
	CheckCapcity(ps);
	/*int end = ps->size - 1;
	
	while ((int)pos <= end)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}*/
	//2--这种就可以不用强转，都可以
	size_t end = ps->size;
	while (end > pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;

}
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	assert(pos < ps->size);
	size_t tmp = pos;
	while (tmp < ps->size)
	{
		ps->a[tmp] = ps->a[tmp + 1];
		tmp++;
	}
	ps->size--;
}

test.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include"SeqList.h"
void Test()
{
	SeqList sl;
	SeqListInit(&sl);



	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushFront(&sl, 5);
	SeqListPopFront(&sl);
	SeqListPopFront(&sl);
	SeqListPopFront(&sl);
	SeqListPopFront(&sl);
	SeqListPopFront(&sl);
	SeqListPopBack(&sl);

	SeqListPrint(&sl);
	SeqListDestory(&sl);
}
void Test2()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushFront(&sl, 1);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 2);
	SeqListPushFront(&sl, 2);
	SeqListErase(&sl, 0);
	SeqListErase(&sl, 0);
	SeqListErase(&sl, 0);
	SeqListErase(&sl, 0);
	SeqListErase(&sl, 0);
	SeqListErase(&sl,0);
	SeqListPrint(&sl);
	SeqListDestory(&sl);


}
int main()
{
	Test2();
	return 0;
}