数据结构之顺序表(超详解)

数据结构之顺序表(超详解)

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是⼀种在实际中广泛使 用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。

物理结构上不一定连续，逻辑结构上连续是什么意思呢？我们拿顺序表和链表举例就可以明白

概念：顺序表是用⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采用数组存储。

这看起来不就是数组么？那么顺序表和数组又有什么区别呢？ 实质上：顺序表的底层就是数组，而顺序表对数组进行了封装，可以完成增删查改等操作…… 形象来说数组是苍蝇馆子，而顺序表则是米其林餐厅，同一种原料，但装饰是不同的。

2.1分类

2.1.1 静态顺序表

使用静态顺序表有个缺陷：

1. 当数组空间给大时，容易造成浪费(如果开辟了10000个空间大小,里面只存了几个数据)；
2. 或者数组空间给小时又不够用。那么如何解决这个问题呢？ 于是我们提出了使用动态顺序表

2.2.2 动态顺序表

如果我们使用动态顺序表，那么就需要定义一个空间容量，当空间不够时可以动态增容。 重命名int 为SLDataType，这样做的好处是如果我们存储的是字符形的顺序表，则只需要在重命名中将int形改成char形即可，而不需要在每一处涉及整形数组中的地方修改，方便了许多。

2.2 初始化、销毁

初始化时此顺序表并没有插入任何数据，因此需要将size和capacity都置为0。

知道了顺序表的初始化，那么相对应的销毁也可以实现。

2. 头插、尾插

尾插

当要像顺序表的尾部插入数据时，将数据插入size中，同时让size++。

那如果空间不够的时候呢？是否又可以拿数据进行尾插呢？肯定是不可以的，插入的数据会越界。 因此需要增容以继续插入新的数据。

增容

什么情况下进行增容呢？ 当size == capacity的时候表示不能再插入数据，这时就要增容。 现在又面临一个问题，增容需要增多少倍合适呢？ 增容过小后面就需要多次增容(导致性能低下等问题)， 增容过大又容易造成空间的浪费， 较为合适的情况是增加1倍或两倍(需从数学角度解释)。

为什么这块新开辟好的空间不直接让ps->arr接收呢？ 目的是防止realloc失败，成为ULL指针。

头插

同样进行头插的时候也可能会面临空间不足的情况，因此我们可以考虑通过调用函数的方法把申请空间(增容)封装成一个函数，需要使用到的情况下直接调用这个函数。

顺序表打印

2.4 头删、尾删

尾删

1. 要保证顺序表里面还有顺序才可以删除数据(因此需要assert(ps->size)；
2. 让ps->size–则完成了尾删。

头删

头删的操作其实与头插的操作类似，需要注意的是ps->arr[0]=ps->arr[1],ps->arr[1]=ps->arr[2]……这样的顺序，如果是ps->arr[ps->size-2]=ps->arr[ps->size-1],ps->arr[ps->size-]=ps->arr[ps->size-2],则会把原来数据覆盖掉。

2.5 指定位置插入、删除、查数据

指定位置插入数据

1. pos位置插入数据必须满足pos在[0,ps->size]之间
2. 让pos后的位置往后挪动一位
3. 插入完成后让ps->size++

指定位置删除、查数据

和指定位置插入数据的方法是类似的

删除数据

查数据

在项目工程当中，其实并不是在一个源文件中写下所有代码，而是创建测试文件，源文件(定义)，头文件(声明)完成代码功能实现。

Seqlist.h

#define _CRT_SECURE_O_WARIGS 1
#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
//顺序表-->底层就是数组
//但是提供了很多现成的方法，开箱即用，是很厉害的新的数据结构

//顺序表是线性表的一种
//        物理结构      逻辑结构
//顺序表    连续          连续
//线性表   不一定连续      连续

//静态顺序表
//struct SeqList
//{
//	int arr[100];//定长数组
//	int size;//有效数据个数
//};

typedef int SLDataType;
动态顺序表
typedef struct SeqList
{
	SLDataType* arr;
	int size;//有效数据个数
	int capacity;//空间大小
}SL;

//顺序表的初始化
void SLInit(SL* ps);
//顺序表的销毁
void SLDestroy(SL* ps);
//顺序表的打印
void SLPrint(SL s);

//头部插入删除/尾部插入删除
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);
//尾删
void SLPopBack(SL* ps);
//头删
void SLPopFront(SL* ps);

//指定位置插入数据
void SLInsert(SL* ps, int pos, SLDataType x);
//指定位置删除数据
void SLErase(SL* ps, int pos);

//查指定位置的数据
int SLFind(SL* ps, SLDataType x);

#define _CRT_SECURE_O_WARIGS 1

#include"SeqList.h"
//顺序表的初始化
void SLInit(SL* ps)
{
	ps->arr = ULL;
	ps->size = ps->capacity = 0;
}
//顺序表的销毁
void SLDestroy(SL* ps)
{
	if (ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = ULL;
	ps->size = ps->capacity = 0;
}

//检测空间是否不足
void CheckCapacity(SL* ps)
{
	if (ps->capacity == ps->size)
	{
		//申请空间
		//malloc calloc realloc int arr[10] -->增容realloc
		//三目表达式
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));//要申请多大空间
		if (tmp == ULL)
		{
			perror("realloc");
			exit(1);//退出程序
		}
		//空间申请成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}

//尾插
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	//ps->arr[ps->size] = x;
	//ps->size++;
	//插入之前先看数据够不够
	CheckCapacity(ps);
	ps->arr[ps->size++] = x;
}
//头插
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	for (int i = ps->size;i > 0;i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}
//顺序表的打印
void SLPrint(SL s)
{
	for (int i = 0;i < s.size;i++)
	{
		printf("%d ", s.arr[i]);
	}
	printf("\n");
}
//尾删
void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	--ps->size;
}
//头删
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	for (int i = 0;i < ps->size - 1;i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//指定位置插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	//查看空间够不够
	CheckCapacity(ps);
	//让pos后的位置往后挪动一位
	for (int i = ps->size;i > pos;i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}
//指定位置删除数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	for (int i = pos;i < ps->size - 1;i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//查指定位置的数据
int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0;i < ps->size;i++)
	{
		if (ps->arr[i] == x)
		{
			//到了
			return i;
		}
	}
	//没有到
	return -1;
}

#define _CRT_SECURE_O_WARIGS 1

#include"SeqList.h"

void SLTest01()
{
	SL sl;
	SLInit(&sl);
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, );
	SLPushBack(&sl, 4);
	SLPushBack(&sl, 5);
	SLPushFront(&sl, 6);
	SLPrint(sl);
	SLPopBack(&sl);
	SLPrint(sl);
	SLPopFront(&sl);
	SLPrint(sl);
	SLInsert(&sl, 2, 5);
	SLPrint(sl);
	SLErase(&sl, 2);
	SLPrint(sl);
	int find = SLFind(&sl, 4);
	if (find < 0)
	{
		printf("没有到!\n");
	}
	else
	{
		printf("到了！下标为%d\n", find);
	}
	SLDestroy(&sl);
}

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

其实这个顺序表的实现并不是很完美，它还是有诸多问题需要顾虑 • 中间/头部的插入删除，时间复杂度为O() • 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。 • 增容⼀般是呈2倍的增长，势必会有⼀定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插⼊了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。 • 初始化的时候并没有分配一定空间，刚开始插入数据的时候就要进行增容问题，这个需要用到C++中的缺省参数 才能解决。