顺序表讲解和实现

最新推荐文章于 2023-08-23 21:00:49 发布

DR5200

最新推荐文章于 2023-08-23 21:00:49 发布

阅读量1.6k

点赞数 12

分类专栏：数据结构文章标签：数据结构算法顺序表 c语言

本文链接：https://blog.csdn.net/DR5200/article/details/113817924

版权

数据结构专栏收录该内容

9 篇文章 1 订阅

订阅专栏

文章目录

一.线性表
二.顺序表
三.完整代码实现

一.线性表

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

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

二.顺序表

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

顺序表一般可以分为：

（1）静态顺序表：使用定长数组存储。

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

但采用静态存储有这样的缺点:

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。因此基本上我们都是使用动态顺序表，根据我们的实际需要，动态的分配空间大小。

（2）动态顺序表：使用动态开辟的数组存储。(实现采用分文件编写的形式)

首先在 .h 文件中给出我们所要实现功能的函数声明

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

功能实现:
(1) 顺序表初始化

将结构体中的指针 array 指向动态开辟的数组，有效数据个数 size 初始化为 0 ，数组最大容量为capacity

ps为指向结构体的指针，capacity为数组最大容量

void SeqListInit(SeqList* ps, size_t capacity)
{
	assert(ps);
	// array 指向动态开辟的数组
	ps->array = (SLDataType*)malloc(sizeof(SLDataType) * capacity);
	if (ps->array == NULL)
	{
		printf("初始化失败\n");
		exit(-1);
	}
	// 有效数据个数 size 初始化为 0 
	ps->size = 0;
	// 数组最大容量为capacity
	ps->capacity = capacity;
}

(2) 顺序表打印

打印出数组中的每一个元素

// 顺序表打印
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	size_t i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->array[i]);
	}
	printf("\n");
}

(3) 顺序表扩容

如果有效数据 size 的个数大于等于数组的最大容量 capacity，需要使用realloc函数对该数组进行扩容操作。

// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* ps)
{
	assert(ps);
	// 进行扩容操作
	if (ps->size >= ps->capacity)
	{
		ps->capacity *= 2;
		ps->array = (SLDataType*)realloc(ps->array, sizeof(SLDataType) * ps->capacity);
		if (ps->array == NULL)
		{
			printf("扩容失败\n");
			exit(-1);
		}
	}
}

(4) 顺序表尾插

在进行插入操作时，首先要判断数组中有效数据 size 的个数是否已满，调用CheckCapacity函数即可，因为size的个数为数组最后一个元素的后一位置的下标，因此执行 ps->array[ps->size] = x; 之后size++即可

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

(5) 顺序表尾删

顺序表尾删只需将 size- -即可，虽然在数组中并未真正的删除尾元素，但我们在打印时不会再打印出尾元素，这样就达到了类似删除尾元素的目的.

// 顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	ps->size--;
}

(6) 顺序表头插

在进行插入操作时 , 首先要判断数组中有效数据 size 的个数是否已满，调用CheckCapacity函数即可，之后将数组中的元素向后移动，将待插入元素插入到数组第一个位置处，size++即可

// 顺序表头插
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	assert(ps);
	// 检查有效数据个数是否已满
	CheckCapacity(ps);
	int i = ps->size - 1;
	// 移动数组元素
	for (i = ps->size - 1; i >= 0; i--)
	{
		ps->array[i + 1] = ps->array[i];
	}
	// 插入元素
	ps->array[0] = x;
	// 有效个数++
	ps->size++;
}

(7) 顺序表头删

将数组中的元素向前移动，之后 size- - 即可

// 顺序表头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	int i = 0;
	// 将数组的元素向前移动
	for (i = 0; i < ps->size - 1; i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	// size--
	ps->size--;
}

(8) 顺序表查找

遍历数组中的元素，找到待查找元素后返回待查找元素的下标.

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

(9) 顺序表在pos位置插入x

具体思路和头插，尾插一样

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	int i = ps->size - 1;
	for (i = ps->size - 1; i >= pos - 1; i--)
	{
		ps->array[i + 1] = ps->array[i];
	}
	ps->array[i + 1] = x;
	ps->size++;
}

(10) 顺序表删除pos位置的值

具体思路和头删，尾删一样

// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	int i = pos - 1;
	for (i = pos - 1; i < ps->size - 1; i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}

三.完整代码实现

SeqList.h文件

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

SeqList.c文件

#include"SeqList.h"
#include<stdio.h>
// 顺序表初始化
void SeqListInit(SeqList* ps, size_t capicity)
{
	assert(ps);
	ps->array = (SLDataType*)malloc(sizeof(SLDataType) * capicity);
	if (ps->array == NULL)
	{
		printf("初始化失败\n");
		exit(-1);
	}
	ps->size = 0;
	ps->capicity = capicity;
}
// 顺序表打印
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	size_t i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->array[i]);
	}
	printf("\n");
}
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->size >= ps->capicity)
	{
		ps->capicity *= 2;
		ps->array = (SLDataType*)realloc(ps->array, sizeof(SLDataType) * ps->capicity);
		if (ps->array == NULL)
		{
			printf("扩容失败\n");
			exit(-1);
		}
	}
}
// 顺序表尾插
void SeqListPushBack(SeqList* ps, SLDataType x)
{
	CheckCapacity(ps);
	ps->array[ps->size] = x;
	ps->size++;
}
// 顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	ps->size--;
}
// 顺序表头插
void SeqListPushFront(SeqList* ps, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	int  i = ps->size - 1;
	for (i = ps->size - 1; i >= 0; i--)
	{
		ps->array[i + 1] = ps->array[i];
	}
	ps->array[0] = x;
	ps->size++;
}
// 顺序表头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size - 1; i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}
// 顺序表查找
int SeqListFind(SeqList* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->array[i] == x)
		{
			return i;
		}
	}
}
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
{
	assert(ps);
	CheckCapacity(ps);
	int i = ps->size - 1;
	for (i = ps->size - 1; i >= pos - 1; i--)
	{
		ps->array[i + 1] = ps->array[i];
	}
	ps->array[i + 1] = x;
	ps->size++;
}
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	int i = pos - 1;
	for (i = pos - 1; i < ps->size - 1; i++)
	{
		ps->array[i] = ps->array[i + 1];
	}
	ps->size--;
}

test.c文件

#include"SeqList.h"
#include<stdio.h>
// 测试头尾插入删除
void TestSeqList()
{
	SeqList s;
	SeqListInit(&s, 3);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s);
	SeqListPushFront(&s, -1);
	SeqListPrint(&s);
	SeqListPopFront(&s);
	SeqListPrint(&s);
	SeqListInsert(&s, 2, 5);
	SeqListPrint(&s);
	SeqListErase(&s, 2);
	SeqListPrint(&s);

}
int main()
{
	TestSeqList();

}

DR5200

关注

12
点赞
踩
8

收藏

觉得还不错? 一键收藏
5
评论
顺序表讲解和实现

文章目录一.线性表二.顺序表一.线性表线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。二.顺序表顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表一般可以分为：（1）静态顺序表
复制链接

扫一扫