顺序表详解（如何实现顺序表）

文章目录

前言

在进入顺序表前，我们先要明白，数据结构的基本概念。

一、数据结构的基本概念

1.1什么是数据结构

数据结构是由"数据"和"结构"两词组合而来。所谓数据就是？常见的数值1、2、3、4.....、姓名、性别、年龄，等。这些都是数据。所谓结构就是当我们想要使用大量同⼀类型的数据时，我们可以借助数组这样的数据结构将大量的数据组织在⼀起，结构也可以理解为组织数据的方式。

1.2数据结构的两个层次

数据结构的两个层次分为逻辑结构和存储结构，逻辑结构与数据的存储无关独立于计算机从具体问题抽象出来的数学模型模。逻辑结构分为线性结构和非线性结构，这里不再强调。存储结构分为顺式存储结构和链式存储结构，今天我们所说的顺序表就是顺数存储结构，链式存储结构的代表就是链表。

1.3最基础的数据结构：数组

二.顺序表的概念及结构

概念：之前说了最基础的数据结构就是数组，它的概念:顺序表其实就是数组，但是在宿主的基础上，他还要求数据必须从头开始连续存放，并且中间不能跳跃间隔。

2.1结构

顺序表它分为静态顺序表和动态顺序表

静态顺序表

静态顺序表需要用#define来开辟，静态的特点就是N给小了不够用，给大了又浪费，所以我们所说的顺序表一般都是指的动态顺序表。

动态顺序表

2.2接口函数

接口函数就是某个模块写了（主要）给其它模块用的函数。简单的说接口函数就是类中的公有数。顺序表的实现主要是以接口函数来实现的

三.动态顺序表的实现

顺序表（seplist），我们重命名为SL，完成这个它我们使用3个文件，SL.h来放函数的声明，SL.cpp来放函数的定义，test.c来放可执行程序。

3.1一个经典的错误（初始化）

cpp 复制代码

void SLInit(SL ps)
{
	ps.a = NULL;

	ps.size = ps.capacity = 0;

}

void testSL1()
{
    SL S1;
    SLInit(SL);
}

为什么这个代码无法运行？？？

因为在函数中的形参跟实参是有区别的形参的改变，不会影响到实参的，形参只是实参的一份临时拷贝，所以要用指针来找地址。

所以正确的初始化应该要这样

cpp 复制代码

void SLInit(SL* ps)
{
	ps->a = NULL;

	ps->size = ps->capacity = 0;

}


void testSL1()
{
    SL S1;

    SLInit(&SL);
}

3.2接口函数之尾插

在一个数组中，如果我们想在末尾插入一个数，我们该怎么插入呢？这就是我们要想如何完成这个接口函数。

往末尾插东西，我们就要做到3点考虑，一.没有空间,刚刚好，二.空间不够的时候要进行扩容，三.空间足够的时候我们就直接插入。

先来看最容易的情况就是直接尾删

cpp 复制代码

void SLpushBack(SL* ps, SLDataType x)
{
	ps->a[ps->size] = x;
	ps->size++;
}

然后我们在想我们前三点要注意的事情，如果没有空间或者空间不足了的话，我就要扩容，我们可以先将有效个数和空间容量相等来形成一个新的有效空间，这里我用了一个三目操作符，如果他们都等于零，我就给他付个值不等于零，我就翻倍在这个地方的扩容，我们就能想到realloc函数的扩容。过完之后我们还要判断一下，如果为空指针的话我们就要报警告，最后把我开辟的新空间重新付给a就可以了。

cpp 复制代码

void SLPushBack(SL* ps, SLDataType x)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));

		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}

	ps->a[ps->size] = x;
    ps->size++;

}

其实扩容这一步，我们完成了另外一种接口函数的使用，那就是检查扩容，我们可以用一个步骤来开辟一个新的结构函数就是检查扩容void SLCheckCapacity(SL* ps)；这样对于后面的来使用就会更加方便。

3.3接口函数之尾删

尾删就非常简单了，我们只要防止数组越界就可以了，我们这里利用断言来警告他不能越界。

cpp 复制代码

void SLPopBack(SL* ps)
{
	assert(ps->size > 0);
	{
		ps->size--;
	}
}

3.4接口函数之头插

头插的话想在第一个数前放一个位置，我们就把已经存放的数每个都向后移一个，注意:如果容量空间已到最大则需开辟空间，所以这就用到了我们之前所讲的检查扩容这个接口函数，所以在头差之前我们先要来检查一下扩容，如果容量够就可以进行头差，如果不够就扩容。

cpp 复制代码

void SLPushFront(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);
	//挪动数据
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

3.5接口函数之头删

先思考为什么头删不可以size--???

因为根据顺序表的概念必须从头开始连续存放，并且中间不能跳跃间隔。

所以这个地方我们采取先挪动在尾删的方式。

cpp 复制代码

void SLPopFront(SL* ps)
{
	assert(ps->size > 0);
		//挪动数据
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

3.6还原空间

因为我们之前动态开辟了内存，所以说我们肯定要把这个内存进行释放。

cpp 复制代码

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

3.7接口函数之查找

查找的意思就是说找到对应元素所在的下标，即便他有多个也没关系，顺序表是从头到尾开始存放的，但是存放的内容不一定需要从头到尾他还可以存放字符等各种变量。

cpp 复制代码

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

3.8接口函数之在指定的pos下标位置插入

pos下标也是有要求，他不可以违背顺序表的概念

其实挪动方法都是一样的，不管是尾插还是头插它的移动方法其实是一样的

cpp 复制代码

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while(end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

3.9接口函数之删除pos下标位置的数据

其实挪动方法都是一样的，不管是尾插还是头插它的移动方法其实是一样的，挪动的方式是一样的，只是可能方向不一样，做法是一样的，然后我们还是要判断下标的合法性

cpp 复制代码

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

4.0复用

这个时候有没有突然间恍然大悟大！！！

之前写的头删尾删头差尾插好像都可以用pos去代替去完善

cpp 复制代码

头删
void PushBack(SL* ps)
{
	SLErase(ps, ps->0);
}
尾删
void SLPopBack(SL* ps)
{
	SLErase(ps, ps->size-1);
}
头插
void SLPushFront(SL* ps, SLDataType x)
{
	SLInsert(ps, ps->0,X);
}
尾插
void SLpushBack(SL* ps, SLDataType x)
{
	SLInsert(ps, ps->size, X);
}

这就是复用。

四.整体的实现

cpp 复制代码

SL.h
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
//#define N 1000
typedef int SLDataType;
#pragma once
typedef struct SeqList
{
	SLDataType * a;//动态开辟的数组大小
	int size; // 有效数据个数
	int capacity; // 空间容量

}SL;
void SLInit (SL* ps);//初始化
void SLPrint(SL* ps);//打印
void SLCheckCapacity(SL* ps);//检查扩容
void SLDestory(SL* ps);//销毁，还原空间
void SLpushBack(SL* ps, SLDataType x);//尾插
void SLPopBack(SL* ps);//尾删
void SLPushFront(SL* ps, SLDataType x);//头插
void SLPopFront(SL* ps);//头删
int SLFind(SL* ps, SLDataType x);//查找
void SLInsert(SL* ps, int pos, SLDataType x);//在指定的pos下标位置插入
void SLErase(SL* ps, int pos);//删除pos位置的数据

cpp 复制代码

SL.cpp
#include"SL.h"
//初始化
void SLInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;

}

//打印
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d", ps->a[i]);
	}
	printf("\n");
}

//检查扩容
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity * sizeof(SLDataType));

		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

//销毁，还原空间
void SLDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

//尾插
void SLpushBack(SL* ps, SLDataType x)
{
	ps->a[ps->size] = x;
	ps->size++;
}

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

//头插
void SLPushFront(SL* ps, SLDataType x)
{
	SLCheckCapacity(ps);
	//挪动数据
	int end = ps->size - 1;
	while (end >= 0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

//头删
void SLPopFront(SL* ps)
{
	assert(ps->size > 0);
		//挪动数据
	int begin = 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
	ps->size--;
}

//查找
int SLFind(SL* ps, SLDataType x)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[ps->size] == x)
		{
			return i;
		}
	}
	return -1;
}

//在指定的pos下标位置插入
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while(end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

//删除pos位置的数据
void SLErase(SL* ps, int pos)
{
	assert(pos >= 0 && pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		begin++;
	}
}

//头删
//void PushBack(SL* ps)
//{
//	SLErase(ps, ps->0);
//}
//尾删
//void SLPopBack(SL* ps)
//{
//	SLErase(ps, ps->size-1);
//}
//头插
//void SLPushFront(SL* ps, SLDataType x)
//{
//	SLInsert(ps, ps->0,X);
//}
//尾插
//void SLpushBack(SL* ps, SLDataType x)
//{
//	SLInsert(ps, ps->size, X);
//}

总结

有了顺序表，为什么还要学习其他的数据结构？顺序表作为数据结构的最基本，假设数据量非常庞大，频繁的获取数字，有效数据个数会影响程序的执行程序所以说最基础的数据结构提供的操作已经不能完全满足复杂的算法实现只有不断地提升自己才能变得强大。

顺序表详解（如何实现顺序表）

文章目录

前言

一、 数据结构的基本概念

1.1什么是数据结构

1.2数据结构的两个层次

1.3最基础的数据结构：数组

二.顺序表的概念及结构

2.1结构

2.2接口函数

**三.**动态顺序表的实现

3.1一个经典的错误（初始化）

为什么这个代码无法运行？？？

3.2接口函数之尾插

3.3接口函数之尾删

3.4接口函数之头插

3.5接口函数之头删

先思考为什么头删不可以size--???

3.6还原空间

3.7接口函数之查找

3.8接口函数之在指定的pos下标位置插入

3.9接口函数之删除pos下标位置的数据

4.0复用

这个时候有没有突然间恍然大悟大！！！

四.整体的实现

总结

一、数据结构的基本概念

三.动态顺序表的实现