数据结构2——线性表之顺序表

最新推荐文章于 2024-09-28 09:18:19 发布
最新推荐文章于 2024-09-28 09:18:19 发布
阅读量60 收藏 1
点赞数 1
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hg81192/article/details/134361250
版权

一、顺序表的概念及特点（优缺点）

顺序表是一种线性结构，由一组连续的内存空间依次存储数据元素，其每一个元素在内存中的物理地址相邻。顺序表具有以下特点：

  1. 容量固定：顺序表在创建时就需要指定容量，无法动态扩容或缩容；

  2. 索引访问：顺序表中的元素可以直接通过索引访问，时间复杂度为 O(1)；

  3. 插入删除开销较大：在顺序表中插入或删除元素需要移动其他元素，时间复杂度为 O(n)；

  4. 适合大量随机访问：由于元素在内存中的存储位置是连续的，所以适合进行大量的随机访问操作。

顺序表可以用数组来实现，每个元素在数组中的下标就是该元素在顺序表中的索引。

二、顺序表的存储

顺序表的存储方式可以分为 静态存储 和 动态存储 两种。

静态存储：即预先给其分配适当的空间，但在以后得程序中不可更改。若想更改，可以通过宏定义的方式定义一个变量，将其作为数组的大小，在之后可以通过改变这个宏变量的方式改变数组的大小。

动态存储：即不预先给数组分配空间，在插入数据时判断数组是否还有剩余空间（或者最初数组是否已经分配空间），在酌情动态给数组分配适当空间。

 1.顺序表的静态存储
#define N 7
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType array[N];	// 定长数组
	size_t size;			// 有效数组的个数
}SL;
2.顺序表的动态存储
typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* a;  // a是指向动态开辟的数组的指针
	int size;		// 有效数据个数
	int capacity;	// 空间容量
}SL;

静态存储存在明显的缺点：

        不确定事先要给多大空间--（给大浪费，给小不够）。

而动态存储能够很好的解决这个问题，所以更推荐动态存储的存储方式。

 在接下来我们也是用动态的存储方式来实现顺序表的一些简单操作。

三、顺序表的简单操作

直接看函数声明 ↓ （增删查改）

// 顺序表的初始化
void SlInit(SL* ps1);
// 顺序表的销毁
void SLDestroy(SL* ps1);
// 打印顺序表
void SLPrint(SL* ps1);
// 检查数组空间
void SLCheckCapacity(SL* ps1);

// 尾插
void SLPushBack(SL* ps1, SLDataType x);
// 头插
void SLPushFront(SL* ps1, SLDataType x);
// 尾删
void SLPopBack(SL* ps1);
// 头删
void SLPopFront(SL* ps1);

// 指定位置插、删
void SLInsert(SL* ps1, int pos, SLDataType x);
void SLErase(SL* ps1, int pos);

// 查找
int SLFind(SL* ps1, SLDataType x);

四、顺序表功能的实现

1.初始化
void SLInit(SL* ps1)
{
	assert(ps1);        // 断言：判断指向结构体的指针是否为空指针

	ps1->a = NULL;        // 指向数的组指针初始化为NULL
	ps1->size = 0;        // 数组已经存储的数据个数 初始置为 0
	ps1->capacity = 0;    // 数组的大小 初始值置为 0

}
2.插入数据

在插入数据前，要先检查数组是否还有剩余空间 --- SLCheckCapacity

void SLCheckCapacity(SL* ps1)
{
	assert(ps1);        // 同理，检查结构体指针是否为空，若为空则直接报错

	if (ps1->size == ps1->capacity)    // 判断数组是否已经存满了
	{
        /*
            这里预先定义一个整形变量 newCapacity，用来将要开辟的新空间的大小（其实就是数组的
            类型的几倍）
        */
		int newCapacity = ps1->capacity == 0 ? 4 : ps1->capacity * 2; 
        // 这里用 realloc 开辟空间
		SLDataType* tmp = (SLDataType*)realloc(ps1->a, sizeof(SLDataType) * newCapacity);
		if (tmp == NULL)    // 检查空间开辟成功了没
		{
			perror("realloc fail");
			return;
		}

		ps1->a = tmp;        // 把新空间给 数组
		ps1->capacity = newCapacity;    // 更新数组大小
	}
}

然后在插入的函数里直接调用 SLChekCapacity 即可 ↓

尾插 --- SLPushBack：
// 尾插
void SLPushBack(SL* ps1, SLDataType x)
{
	assert(ps1);        // 同上

	SLCheckCapacity(ps1);    // 直接调用检查数组空间的函数

	ps1->a[ps1->size] = x;    // ps1->size 就是数组的最后一个数据的下标+1，所以直接在size处插入数据就可以了
	ps1->size++;            // 数据插进来后，要将size更新
}
头插 --- SLPushFront:
// 头插
void SLPushFront(SL* ps1, SLDataType x)
{
	assert(ps1);

	SLCheckCapacity(ps1);

	//挪动数据(把数据挨个向后移一位)
	int end = ps1->size - 1;        // end 标记下一个要挪动的数据
	while (end >= 0)
	{
		ps1->a[end + 1] = ps1->a[end];   // 这里要注意：向后挪动数据要从最后一位开始从后往前挪
		--end;
	}

	ps1->a[0] = x;        // 在数组的下标0处插入数据，因为前面已经将数据挨个向后移动一位了，所以此时 下标0 处是空着的
	ps1->size++;        // 更新size
}
3.删除数据
        尾删 --- SLPopBack：
// 尾删
void SLPopBack(SL* ps1)
{
	assert(ps1);

	// 暴力检查 -- 检查顺序表是否为空
	assert(ps1->size > 0);

    // 顺序表的删除数据特别简单，只需要把数组存储的数据的个数减一下就好了
	ps1->size--;
}
        头删 --- SLPopFront：
// 头删
void SLPopFront(SL* ps1)
{
	//暴力检查
	assert(ps1->size > 0);

	int begin = 1;
    // 将数据挨个向前移，直到把第一个数据覆盖
	while (begin < ps1->size)
	{
		ps1->a[begin - 1] = ps1->a[begin];
		begin++;
	}

	ps1->size--;    // 跟新size
}
4.查找
// 查找指定数据，返回下标
int SLFind(SL* ps1, SLDataType x)
{
	assert(ps1);

	for (int i = 0; i < ps1->size; i++)    // 循环遍历数组 匹配 目标值，找到返回下标
	{
		if (ps1->a[i] == x)
		{
			return i;
		}
	}

	return -1;
}

        有了 SLFind 函数，就可以先查找数据，然后再用 SLErase 删除指定数据了

5.删除指定位置的数据
void SLErase(SL* ps1, int pos)
{
	assert(ps1);
	assert(pos >= 0 && pos < ps1->size);    // 判断 指定位置的合理性

	// 挪动覆盖， 同头删类似，将指定位置后面的数据挨个向前移一位
	int begin = pos;
	while (begin < ps1->size)
	{
		ps1->a[begin - 1] = ps1->a[begin];
		begin++;
	}
	ps1->size--;   
}
6.在指定位置插入数据
void SLInsert(SL* ps1, int pos, SLDataType x)
{
	assert(ps1);
	assert(pos >= 0 && pos <= ps1->size);    // 判断 下标 pos 的合理性

	SLCheckCapacity(ps1);

	//挪动数据， 同头插类似
	int end = ps1->size - 1;
	while (end >= pos)
	{
		ps1->a[end + 1] = ps1->a[end];
		--end;
	}

	ps1->a[pos] = x;
	ps1->size++;
}
7. 打印顺序表
// 打印

// 循环遍历数组，把数据挨个printf一下
void SLPrint(SL* ps1)
{
	assert(ps1);
	for (int i = 0; i < ps1->size; i++)
	{
		printf("%d ", ps1->a[i]);
	}
	printf("\n");
}
8.销毁顺序表

        最后，在退出程序时要把结构体内容重新置为空并释放掉内存。

// 销毁
void SLDestroy(SL* ps1)
{
	assert(ps1);

	if (ps1->a != NULL)    // 判断数组是否为空
	{
		free(ps1->a);        //   释放掉分配给数组的空间
		ps1->a = NULL;        // 将结构体的内容置空
		ps1->size = 0;
		ps1->capacity = 0;
	}
}

至此，顺序表的一些简单操作就都实现啦。

总代码 ↓

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* a;
	int size;		// 有效数据个数
	int capacity;	// 空间容量
}SL;

void SlInit(SL* ps1);
void SLDestroy(SL* ps1);
void SLPrint(SL* ps1);

void SLCheckCapacity(SL* ps1);

// 尾插
void SLPushBack(SL* ps1, SLDataType x);
// 头插
void SLPushFront(SL* ps1, SLDataType x);
// 尾删
void SLPopBack(SL* ps1);
// 头删
void SLPopFront(SL* ps1);
// 指定位置插、删
void SLInsert(SL* ps1, int pos, SLDataType x);
void SLErase(SL* ps1, int pos);

// 查找
int SLFind(SL* ps1, SLDataType x);


void SLInit(SL* ps1)
{
	assert(ps1);

	ps1->a = NULL;
	ps1->size = 0;
	ps1->capacity = 0;

}

void SLDestroy(SL* ps1)
{
	assert(ps1);

	if (ps1->a != NULL)
	{
		free(ps1->a);
		ps1->a = NULL;
		ps1->size = 0;
		ps1->capacity = 0;
	}
}

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

void SLCheckCapacity(SL* ps1)
{
	assert(ps1);

	if (ps1->size == ps1->capacity)
	{
		int newCapacity = ps1->capacity == 0 ? 4 : ps1->capacity * 2;
		SLDataType* tmp = (SLDataType*)realloc(ps1->a, sizeof(SLDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		ps1->a = tmp;
		ps1->capacity = newCapacity;
	}
}

void SLPushBack(SL* ps1, SLDataType x)
{
	assert(ps1);

	SLCheckCapacity(ps1); 

	ps1->a[ps1->size] = x;
	ps1->size++;
}

void SLPushFront(SL* ps1, SLDataType x)
{
	assert(ps1);

	SLCheckCapacity(ps1);

	//挪动数据(把数据挨个向后移一位)
	int end = ps1->size - 1;
	while (end >= 0)
	{
		ps1->a[end + 1] = ps1->a[end];
		--end;
	}

	ps1->a[0] = x;
	ps1->size++;
}

void SLPopBack(SL* ps1)
{
	assert(ps1);

	//温柔检查
	/*if (ps1->size == 0)
	{
		return;
	}*/

	//暴力检查
	assert(ps1->size > 0);

	ps1->size--;
}

void SLPopFront(SL* ps1)
{
	//暴力检查
	assert(ps1->size > 0);

	int begin = 1;
	while (begin < ps1->size)
	{
		ps1->a[begin - 1] = ps1->a[begin];
		begin++;
	}

	ps1->size--;
}

void SLInsert(SL* ps1, int pos, SLDataType x)
{
	assert(ps1);
	assert(pos >= 0 && pos <= ps1->size);

	SLCheckCapacity(ps1);

	//挪动数据
	int end = ps1->size - 1;
	while (end >= pos)
	{
		ps1->a[end + 1] = ps1->a[end];
		--end;
	}

	ps1->a[pos] = x;
	ps1->size++;
}

void SLErase(SL* ps1, int pos)
{
	assert(ps1);
	assert(pos >= 0 && pos < ps1->size);

	// 挪动覆盖
	int begin = pos;
	while (begin < ps1->size)
	{
		ps1->a[begin - 1] = ps1->a[begin];
		begin++;
	}
	ps1->size--;
}

int SLFind(SL* ps1, SLDataType x)
{
	assert(ps1);

	for (int i = 0; i < ps1->size; i++)
	{
		if (ps1->a[i] == x)
		{
			return i;
		}
	}

	return -1;
}




// TestSL 是测试功能函数
void TestSL1()
{
	SL s1;
	SLInit(&s1);
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPushBack(&s1, 5);
	SLPushBack(&s1, 6);
	SLPushBack(&s1, 7);
	SLPushBack(&s1, 8);
	SLPushBack(&s1, 9);

	SLPrint(&s1);

	SLPushFront(&s1, 10);
	SLPushFront(&s1, 20);
	SLPushFront(&s1, 30);
	SLPushFront(&s1, 40);

	SLPrint(&s1);

	SLDestroy(&s1);
}

void TestSL2()
{
	SL s1;
	SLInit(&s1);
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPushBack(&s1, 5);
	
	SLPrint(&s1);

	SLPopBack(&s1);
	
	SLPrint(&s1);

	SLDestroy(&s1);
}

void TestSL3()
{
	SL s1;
	SLInit(&s1);
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPushBack(&s1, 5);

	SLPrint(&s1);

	SLPopFront(&s1);
	SLPopFront(&s1);
	SLPopFront(&s1);
	SLPopFront(&s1);

	SLPrint(&s1);
}

void TestSL4()
{
	SL s1;
	SLInit(&s1);
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPushBack(&s1, 5);

	SLPrint(&s1);

	SLInsert(&s1, 4, 10);

	SLPrint(&s1);

	SLErase(&s1, 2);

	SLPrint(&s1);

	int pos = SLFind(&s1, 3);
	if (pos != -1)
	{
		SLErase(&s1, pos+1);
	}
	SLPrint(&s1);
}

// 主函数
int main()
{
	//TestSL1();
	//TestSL2();
	//TestSL3();
	TestSL4();

	return 0;
}

Treant、
关注
数据结构基础——线性表之顺序表的插入删除查找操作（附C语言代码）
qq_62316014的博客
04-14 2034
本文阐述了顺序表的一些基本操作——插入删除查找，并附上C语言代码。
数据结构之——线性表与顺序表
xqx_999的博客
09-15 941
线性表与顺序表的概念，以及顺序表的接口实现。
数据结构与算法——线性表（顺序表篇）
小田是个程序员的博客欢迎你的到来呀~
06-11 7495
线性表且最简单的一种数据结构， 一个线性表是n个数据元素的有限序列 。本篇文章主要详细解读了线性表的基本概念，以及线性表中顺序表的重点知识。详细分析了顺序表的基本操作，图文结合，易于理解。............
数据结构——线性表之顺序表
weixin_68153081的博客
09-04 1874
数据结构——线性表之顺序表
数据结构——线性表（顺序表）
2302_80243065的博客
07-20 1235
数据结构是计算机四大件之一，是与计算机组成原理、操作系统、计算机网络齐名的存在，因此数据结构的重要性不言而喻。本章将带领大家走进数据结构的世界，我们从最基本的线性表中的顺序表讲起。
数据结构(二)——线性表(顺序表)
señoritaw的博客
03-06 1161
顺序表：用顺序存储的方式实现线性表顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中C语言中通过sizeof(ElementType)可以知道一个数据元素的大小。
【数据结构——线性表之顺序表】
lflcodeplus的博客
09-26 2847
线性表之《顺序表的表示及基本操作的实现》
数据结构————线性表之顺序表
Blue_gank的博客
08-06 138
小白创建顺序静态表
数据结构——线性表之顺序表的基本操作讲解
weixin_69283129的博客
08-21 1932
（C语言版）数据结构——线性表之顺序表的基本操作讲解
数据结构篇——线性表之顺序表
qq_42816520的博客
01-09 1598
1、线性表 （1）定义 线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长，当n=0时，该线性表时是一个空表。若以L命名线性表，则其一般表示为 其中a1是唯一的“第一个”数据元素，又称为表头元素；an是唯一的“最后一个”元素，又称为表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。 （2）特点 表中元素的个数有限。...
数据结构——线性表和顺序表
weixin_45732274的博客
03-08 1429
1. 认识线性表和顺序表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 1.顺序表（逻辑上线性，在内存中存储时，也是严格按照逻辑上的次序保存起来） 2.链表（逻辑上线性，在内存中存储时，不保证连续性） 注意： 顺序表中一定要区分两个概念 容量(capac
数据结构实战——线性表（顺序表、链表——单链表、双链表、循环链表、静态链表）
wypds的博客
04-09 1036
数据结构线性表实战 顺序表、单链表（头插法、尾插法、双链表、循环链表、静态链表） 一、什么是线性表 二、顺序表 三、链表 一、单链表 1、头插法 2、尾插法 二、双链表 三、循环链表 四、静态链表 前言 提示：这里可以添加本文要记录的大概内容： 数据结构——线性表 提示：以下是本篇文章正文内容，下面案例可供参考 一、什么是线性表 线性表是具有相同数据类型的n(>=0)个数据元素的有限序列，n为表长，n=0时线性表是一个空表。若用L命名线性表，一般表示为：L=(a[1]，a[2]，a[3]，.
数据结构——线性表（顺序表的增、删、查）
Duanqi1的博客
07-06 661
-------顺序表介绍------- 线性表的顺序存储又称顺序表; 用一组地址连续的存储单元（数组)依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。一维数组可以静态分配，也可以动态分配。关于静态分配，数组的大小可空间事先固定，空间占满，加入新数据就会溢出。动态分配，存储空间通过执行程序中的动态分配存储语句实现，一旦数据空间占满，就另外开辟一块更大的存储空间，用来替换原来的存储空间，从而达到扩充存储的目的。 特点： 增删操作需移动大量数据元素; 支持随机存取。 ---------
数据结构——线性表的顺序表示与实现（顺序表）
流楚丶格念的博客
09-22 7732
文章目录线性结构的定义：线性表一、线性表的定义和特点例1 分析26 个英文字母组成的英文表例2 分析学生情况登记表顺序存储结构存在问题二、线性表的类型定义 线性结构的定义： 若结构是非空有限集，则有且仅有一个开始结点和一个终端结点，并且所有结点都最多只有一个直接前趋和一个直接后继。 可表示为：（a1 , a2 , ……, an） 线性表 线性结构表达式：（a1 , a2 , ……, an） 线性结构的特点： ① 只有一个首结点和尾结点； ② 除首尾结点外，其他结点只有一个直接前驱
数据结构：树的定义及其性质
pranaa的博客
09-24 700
树是一种重要的非线性数据结构，树作为一种逻辑结构，同时也是一种分层结构。具有以下两个特点：1.树的根结点没有前驱，除根结点意外的节点只有一个前驱2.树中所有结点都可以有0个或多个后继树结构在多个领域都有广泛应用，如表示文件系统的结构、数据库的索引、层次数据关系等。具体来说，树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。
数据结构之——栈
m0_71974552的博客
09-24 1168
栈：数据结构的基石
matlab的‌基础语法和数据类型
weixin_45710581的博客
09-25 581
MATLAB中的函数用于封装可重复使用的代码块。
数据结构：详解搜索二叉树
最新发布
Another_Shi的博客
09-28 762
搜索二叉树的结构跟二叉树差不多——两个指针来指向左右子树，一个对象来存放数据。
数据结构：树、森林
pranaa的博客
09-24 992
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
数据结构实验：线性表操作与实现——顺序表与链表
"该文档是关于浙江理工大学数据结构实验，主要关注线性表的操作与实现。实验分为两部分，一是顺序表的操作，包括创建、查找、插入和删除，以及顺序表的反转；二是链表的操作，同样涉及创建、输出、反转等。实验要求...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值