数据结构精讲——顺序表

Tom王要coding

已于 2022-10-17 10:23:29 修改

阅读量159

点赞数 4

文章标签：数据结构链表算法

于 2022-10-17 10:12:29 首次发布

本文链接：https://blog.csdn.net/weixin_43635473/article/details/127356659

版权

本文详细讲解了线性表中的顺序表数据结构，包括静态和动态顺序表的概念，并重点介绍了动态顺序表的实现。通过C语言代码展示了顺序表的基本操作，如初始化、销毁、增删查改等，特别强调了动态内存管理和容量调整。此外，还提供了完整的测试用例来验证代码的正确性。

摘要由CSDN通过智能技术生成

新手易懂数据结构精讲——顺序表

线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
当然我们之前讲过无头单链表和有头双链表：单链表精讲、循环双向链表

顺序表图片

链表
在这里插入图片描述

顺序表

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

静态顺序表：使用定长数组存储。
动态顺序表：使用动态开辟的数组存储。

有两种顺序表：动态、静态

// 顺序表的静态存储
#define N 100
typedef int SLDataType;
typedef struct SeqList
{
 SLDataType array[N]; // 定长数组
 size_t size; // 有效数据的个数 
}SeqList;


// 顺序表的动态存储
typedef struct SeqList
{
 SLDataType* array; // 指向动态开辟的数组
 size_t size ; // 有效数据个数
 size_t capicity ; // 容量空间的大小
}SeqList;

各有利弊：静态方便和数组基本一样，但是容量有限，超出了容量就无法再录入信息了。动态设置稍微麻烦一点，但是不用再担心容量不够的问题。

顺序表的实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。
我们要设置增删查改这四类基本的操作。
先设置一个动态存储类型

// 顺序表的动态存储
typedef struct SeqList
{
	SLDataType* array; // 指向动态开辟的数组
	size_t size; // 有效数据个数
	size_t capicity; // 容量空间的大小
}SeqList;

之后用malloc动态开辟空间。
初始化
没错顺序表和链表的不同就是它需要初始化。

// 顺序表初始化
void SeqListInit(SeqList* psl)
{
	psl->capicity = 0;
	psl->size = 0;
	psl->array = (SeqList*)malloc(sizeof(SeqList));
}

这里可以给psl->array给他开辟一个小小的空间哦，当然直接给NULL也是可以的，但是少了点人情味（array：1个空间你都不给我？？？）
销毁
和人一样有生就有死亡，顺序表也一样，你用完了是要归还给电脑的，尘归尘土归土。

// 顺序表销毁
void SeqListDestory(SeqList* psl)
{
	free(psl->array);
	psl->array =NULL;
	psl->capicity = 0;
	psl->size = 0;
	
}

打印
是为了方便检验程序是否出错。

// 顺序表打印
void SeqListPrint(SeqList* psl)
{
	assert(psl != NULL);//里面是假则会报错！！！
	int count = psl->size;
	if (count > 0)
	{
		for (int i = 0; i < count; i++)
		{
			printf("%d ", psl->array[i]);
		}
		printf("\n");
	}
	else
	{
		printf("没数可以输出\n");
	}
	
}

增数

// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	CheckCapacity(psl);
	psl->array[psl->size++] = x;
}

增数之前一定要检验一下容量满不满，如果满了就要增容，所以写了一个检查容量的函数（同样也是增容函数）。

// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* psl)
{
	int NewCapacity = 0;
	if (psl->size == psl->capicity)
	{
		/*NewCapacity = psl->capicity == 0 ? 4 : psl->capicity * 2;*/
		if (psl->capicity == 0)
		{
			NewCapacity = 4;
		}
		else
		{
			NewCapacity = psl->capicity * 2;
		}
		SLDataType*  tmp = (SLDataType*)realloc(psl->array, sizeof(SLDataType)*NewCapacity);
		if (tmp == NULL)
		{
			printf("malloc fail\n");
			exit(-1);
		}
		psl->array = tmp;
		psl->capicity = NewCapacity;
	}
	
}

尾插

// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	CheckCapacity(psl);
	psl->array[psl->size++] = x;
}

插入一定要记得增加size的数值。
头插

// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	CheckCapacity(psl);
	for (int i = psl->size - 1; i >= 0; i--)
	{
		psl->array[i + 1] = psl->array[i];
	}
	psl->array[0] = x;
	psl->size++;
}

道理一样，但是要把所有数字都往后移一位，再把array[0]变成X。
删除
尾删

// 顺序表尾删
void SeqListPopBack(SeqList* psl)
{
	if (psl->size > 0)
	{
		psl->size--;
	}
	else
	{
		printf("没有内容，无法删除！");
		return;
	}
	
}

尾删非常简单，其实只需要把size减一个数字就可以了。因为本质他和数组一样只要改变size就可以改变数组内的内容。
头删

// 顺序表头删
void SeqListPopFront(SeqList* psl)
{
	if (psl->size > 0)
	{
		for (int i = 0; i < (psl->size - 1); i++)
		{
			psl->array[i] = psl->array[i + 1];
		}
		psl->size--;
	}
	else
	{
		printf("没有数据，无法删除\n");
	}
	
}

头删和头增很像，只是这次就是把所有数字往前挪一个位置然后size再减一个。
查找
利用循环遍历一遍，如果找到就返回找到的位置，但是找不到就返回一个NULL。

// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x)
{
	assert(psl != NULL);
	for (int i = 0; i < psl->size; i++)
	{
		if (psl->array[i] == x)
		{
			return i + 1;
		}
	}
	return NULL;
}

中插和中删
此环节要和查找联合使用，找到该位置就可以操作了。

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
	CheckCapacity(psl);
	if (pos <= psl->size&&pos>=0)
	{
		for (int i = psl->size - 1; i >= pos; i--)
		{
			psl->array[i + 1] = psl->array[i];
		}
		psl->size++;
		psl->array[pos] = x;
	}
	else
	{
		printf("您输入的位置无效\n");
	}
	
}
// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos)
{
	if (pos < psl->size)
	{
		for (int i =pos; i <psl->size-1; i++)
		{
			psl->array[i] = psl->array[i+1];
		}
		psl->size--;
	}
	else
	{
		printf("您输入的位置无效\n");
	}
}

测试结果

在这里插入图片描述

顺序表的所有程序

头文件

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#define SLDataType int
// 顺序表的动态存储
typedef struct SeqList
{
	SLDataType* array; // 指向动态开辟的数组
	size_t size; // 有效数据个数
	size_t capicity; // 容量空间的大小
}SeqList;
// 基本增删查改接口
// 顺序表初始化
//void SeqListInit(SeqList* psl, size_t capacity);
void SeqListInit(SeqList* psl);
// 顺序表销毁
void SeqListDestory(SeqList* psl);
// 顺序表打印
void SeqListPrint(SeqList* psl);
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* psl);
// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x);
// 顺序表尾删
void SeqListPopBack(SeqList* psl);
// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x);
// 顺序表头删
void SeqListPopFront(SeqList* psl);
// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos);

.c文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
// 顺序表初始化
void SeqListInit(SeqList* psl)
{
	psl->capicity = 0;
	psl->size = 0;
	psl->array = (SeqList*)malloc(sizeof(SeqList));
}
// 顺序表销毁
void SeqListDestory(SeqList* psl)
{
	free(psl->array);
	psl->array =NULL;
	psl->capicity = 0;
	psl->size = 0;
	
}
// 顺序表打印
void SeqListPrint(SeqList* psl)
{
	assert(psl != NULL);//里面是假则会报错！！！
	int count = psl->size;
	if (count > 0)
	{
		for (int i = 0; i < count; i++)
		{
			printf("%d ", psl->array[i]);
		}
		printf("\n");
	}
	else
	{
		printf("没数可以输出\n");
	}
	
}
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* psl)
{
	int NewCapacity = 0;
	if (psl->size == psl->capicity)
	{
		/*NewCapacity = psl->capicity == 0 ? 4 : psl->capicity * 2;*/
		if (psl->capicity == 0)
		{
			NewCapacity = 4;
		}
		else
		{
			NewCapacity = psl->capicity * 2;
		}
		SLDataType*  tmp = (SLDataType*)realloc(psl->array, sizeof(SLDataType)*NewCapacity);
		if (tmp == NULL)
		{
			printf("malloc fail\n");
			exit(-1);
		}
		psl->array = tmp;
		psl->capicity = NewCapacity;
	}
	
}
// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
	CheckCapacity(psl);
	psl->array[psl->size++] = x;
}
// 顺序表尾删
void SeqListPopBack(SeqList* psl)
{
	if (psl->size > 0)
	{
		psl->size--;
	}
	else
	{
		printf("没有内容，无法删除！");
		return;
	}
	
}
// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
	CheckCapacity(psl);
	for (int i = psl->size - 1; i >= 0; i--)
	{
		psl->array[i + 1] = psl->array[i];
	}
	psl->array[0] = x;
	psl->size++;
}
// 顺序表头删
void SeqListPopFront(SeqList* psl)
{
	if (psl->size > 0)
	{
		for (int i = 0; i < (psl->size - 1); i++)
		{
			psl->array[i] = psl->array[i + 1];
		}
		psl->size--;
	}
	else
	{
		printf("没有数据，无法删除\n");
	}
	
}
// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x)
{
	assert(psl != NULL);
	for (int i = 0; i < psl->size; i++)
	{
		if (psl->array[i] == x)
		{
			return i + 1;
		}
	}
	return NULL;
}
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
	CheckCapacity(psl);
	if (pos <= psl->size&&pos>=0)
	{
		for (int i = psl->size - 1; i >= pos; i--)
		{
			psl->array[i + 1] = psl->array[i];
		}
		psl->size++;
		psl->array[pos] = x;
	}
	else
	{
		printf("您输入的位置无效\n");
	}
	
}
// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos)
{
	if (pos < psl->size)
	{
		for (int i =pos; i <psl->size-1; i++)
		{
			psl->array[i] = psl->array[i+1];
		}
		psl->size--;
	}
	else
	{
		printf("您输入的位置无效\n");
	}
}

测试函数（main.c)

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
void TestFunc()
{
	SeqList sl;
	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 5);
	SeqListPrint(&sl);

	SeqListPushFront(&sl, 0);
	SeqListPushFront(&sl, 9);
	SeqListPushFront(&sl, 8);
	SeqListPrint(&sl);

	SeqListPopBack(&sl);
	SeqListPopBack(&sl);
	SeqListPrint(&sl);

	SeqListPopFront(&sl);
	SeqListPrint(&sl);

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