顺序表，表顺序

最新推荐文章于 2024-06-19 23:39:22 发布
最新推荐文章于 2024-06-19 23:39:22 发布
阅读量982 收藏 22
点赞数 24
分类专栏： 数据结构构构构构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73359101/article/details/135829020
版权

目录

一、线性表

二、顺序表

一、线性表

  1. 什么是线性表，从名字上你就能感觉到，是具有像线一样的性质的表。在广场上，有很多人分散在各处，当中有些是小朋友，可也有很多大人，甚至还有不少宠物，这些小朋友的数据对于整个广场人群来说，不能算是线性表的结构。但像现在说的这样，一个班级的小朋友，一个跟着一个排着队，有一个打头，有一个收尾，当中的小朋友每一个都知道TA前面一个是谁，TA后面一个是谁，这样就如同一根线把它们串联起来了， 就可以称之为线性表。————以上的文段出自于《大话数据结构》这本书，我觉得讲的挺生动形象的，于是就搬过来与大家分享。
  2. 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...
    线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

以上便是对线性表的介绍

二、顺序表

1、顺序表的定义

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

2、顺序表中不同的存储结构

  1. 静态存储：使用定长数组存储元素，这种存储结构只适用于知道存储多少数据。

 缺点：由于不知道具体存储的数据，无法及时地修改N的值。

     2.动态存储：使用动态开辟的数组存储，根据需要动态的分配空间大小。

  3、顺序表动态存储的一些功能实现

// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps);
void SeqListDestroy(SeqList* ps);

// 打印表
void SeqListPrint(SeqList* ps);

//头插头删 尾插尾删
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);
void SeqListPopBack(SeqList* ps);

//检查是否需要增容
void SLCheckCapacity(SeqList* ps);

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);
// 顺序表修改值
void SeqListModify(SeqList* ps, int pos, SLDateType x);

初始化顺序表

//初始化顺序表表
void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->a =(SLDateType*) malloc(sizeof(SLDateType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc failed");
		exit(-1);//让程序以异常的方式退出(终止程序)
		//return -1; //以异常的方式返回上一级函数并继续执行余下程序
	}

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

释放所开辟的空间

//释放所开辟的空间
void SeqListDestroy(SeqList* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

打印顺序表

//打印
void SeqListPrint(SeqList* ps)
{
	assert(ps);

	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

检查是否需要增容

//检查是否需要增容
void SLCheckCapacity(SeqList* ps)
{
	assert(ps);

	if (ps->size == ps->capacity)
	{
		SLDateType* tmp = (SLDateType*)realloc(ps->a, ps->capacity * 2 * (sizeof(SLDateType)));
		if (tmp == NULL)
		{
			perror("realloc failed");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity *= 2;
	}
}

头插头删，尾插尾删

头插
//头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps);

	//SLCheckCapacity(ps);

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

	SeqListInsert(ps, 0, x);
}
头删
//头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);

	/*assert(ps->size > 0);
	int begin = 1;
	while (begin < ps->size)
	{	
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;*/
	SeqListErase(ps, 0);
}
尾插
//尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);

	//将原空间的值放入新空间
	/*ps->a[ps->size] = x;
	ps->size++;*/

	SeqListInsert(ps, ps->size, x);
}
尾删
//尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);

	//两种检查的目的：为了防止增加或者删除后会造成越界的后果
	//温柔的检查
	/*if (ps->size == 0)
	{
		return;
	}*/

	//暴力的检查
	//assert(ps->size > 0);//如果是真的就继续执行程序，如果是假的就终止程序

	//ps->a[ps->size - 1] = 0;
	//ps->size--;
	SeqListErase(ps, ps->size);
}

顺序表查找

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);

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

顺序表在pos位置插入x

插入算法的思路：

  1. 如果插入位置不合理，抛出异常；
  2. 如果线性表长度大于等于数组长度，则抛出异常或者动态增加容量；
  3. 从最后一个元素开始向前遍历到第i个位置，分别将它们都向后移动一个位置；
  4. 将要插入的元素填入位置i处；
  5. 表长加1。
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);

	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位置的值

删除算法的思路：

  1. 如果删除位置不合理，抛出异常；
  2. 取出删除元素；
  3. 从删除元素位置开始遍历到最后一个元素位置，分别将它们都向前移动一个位置；
  4. 表长减1。
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);

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

顺序表修改值

// 顺序表修改值
void SeqListModify(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
		
	assert(pos >= 0 && pos < ps->size);
	ps->a[pos] = x;
}

4、线性表顺序存储结构的优缺点

优点

  • 无须为表示表中元素之间的逻辑关系而增加额外的存储空间可以快速地存取表中任一位置的元素;
  • 可以快速地存取表中任意位置的元素；

缺点

  • 插入和删除操作需要移动大量元素 ;
  • 当线性表长度变化较大时,难以确定存储空间的容量 ;
  • 造成存储空间的“碎片";

总代码

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


//初始化顺序表表
void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->a =(SLDateType*) malloc(sizeof(SLDateType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc failed");
		exit(-1);//让程序以异常的方式退出(终止程序)
		//return -1; //以异常的方式返回上一级函数并继续执行余下程序
	}

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

//释放所开辟的空间
void SeqListDestroy(SeqList* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}

//打印
void SeqListPrint(SeqList* ps)
{
	assert(ps);

	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

//检查是否需要增容
void SLCheckCapacity(SeqList* ps)
{
	assert(ps);

	if (ps->size == ps->capacity)
	{
		SLDateType* tmp = (SLDateType*)realloc(ps->a, ps->capacity * 2 * (sizeof(SLDateType)));
		if (tmp == NULL)
		{
			perror("realloc failed");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity *= 2;
	}
}

//尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);

	//将原空间的值放入新空间
	/*ps->a[ps->size] = x;
	ps->size++;*/

	SeqListInsert(ps, ps->size, x);
}

//尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);

	//两种检查的目的：为了防止增加或者删除后会造成越界的后果
	//温柔的检查
	/*if (ps->size == 0)
	{
		return;
	}*/

	//暴力的检查
	//assert(ps->size > 0);//如果是真的就继续执行程序，如果是假的就终止程序

	//ps->a[ps->size - 1] = 0;
	//ps->size--;
	SeqListErase(ps, ps->size);
}

//头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps);

	//SLCheckCapacity(ps);

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

	SeqListInsert(ps, 0, x);
}

//头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);

	/*assert(ps->size > 0);
	int begin = 1;
	while (begin < ps->size)
	{	
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;*/
	SeqListErase(ps, 0);
}

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);

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


// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);

	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 SeqListErase(SeqList* ps, int pos)
{
	assert(ps);

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

// 顺序表修改值
void SeqListModify(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
		
	assert(pos >= 0 && pos < ps->size);
	ps->a[pos] = x;
}

Peace & Love487
关注
  • 24
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
顺序表和链表
passion
08-03 2932
顺序表和链表的简单介绍和实现
顺序表+菜单
06-18
里面包括顺序表的创建，更改，添加，删除元素，遍历顺序表包括菜单功能，代码清晰，结构简单
顺序表
Outtch_的博客
11-07 3552
顺序表是什么呢？ 顾名思义，顺序表是物理地址连续的存储单元依次存储数据的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。 顺序表和数组有什么区别呢? 顺序表比数组更约束，顺序表物理地址上必须连续存储，数组是顺序表在实际编程中的具体实现方式。 顺序表分为静态顺序表和静态顺序表（主要区别在于他们的容量是否可变） 静态顺序表 静态顺序表的概念： 顺序表的容量在静态时期（编译期间）确定，大...
【数据结构】顺序表
加油！！！
10-30 2218
存储单元依次存储。
什么是顺序表
热门推荐
kokopop007的博客
08-25 1万+
顺序表 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。 这样的一组序列元素的组织形式，我们可以将其抽象为...
顺序表中查找元素
北街lhy的博客
03-12 3208
题目：线性表递增有序存放，设计一算法，用最少的时间查找值为x的元素，若找到则将其与后续元素位置相交换，否则，插入使其仍然有序 分析： 题目告知这是一个递增有序表，要使时间最少，我们可以采取折半查找的方式，这样比顺序查找省时。 代码如下： #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> int findAndExchange(int* arr,int n,int len) {//返回数组长度 int low = 0, ...
C实现顺序表
鸽子的博客
08-04 3266
1. 实验目的 （1）掌握线性表的顺序存储结构； （2）验证顺序表及其基本操作的实现； （3）理解算法与程序的关系，能够将顺序表算法转换为对应的程序。 2. 实验内容 （1）建立含有若干个元素的顺序表； （2）对已建立的顺序表实现插入、删除、查找等基本操作。 3. 实验提示 定义顺序表的数据类型——顺序表结构体SeqList，在SeqList基础上实现题目要求的插入...
使用C语言创建顺序表
qq_44871378的博客
09-24 7911
C语言顺序表 C语言顺序表 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR -1 #define MAXSIZE 5 typedef char ElemType ; //声明顺序表的结构体类型 typedef struct{ ElemType *elem; int length; ...
＜数据结构＞ 顺序表
bit_zyx的博客
03-13 9301
目录 一、顺序表介绍 二、准备工作 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
用数组实现顺序表
SNAYi
07-27 2438
顺序表是线性表的一种，本文采用数组实现顺序表，所以它在逻辑结构和物理结构上都是连续的。
顺序表和链表的优缺点
weixin_57023347的博客
06-21 3741
顺序表 定义：在内存中用地址连续的一块存储空间顺序存放线性表的各元素。在程序设计语言中，一维数组在内存中占用的存储空间是一维连续的存储空间，因此我们用一维数组存储数据来表示顺序表。 优点： 由于顺序表是用数组来存储数据，内存空间连续，当访问数据时可以达到使用数组下标的方式随机访问。 CPU高速缓存的命中率高。 解释： 数据保存在内存中，数据是在CPU里进行运算的(逻辑和算术)。但是CPU速度太快，内存的速度跟不上CPU的速度。于是在CPU和内存之间存在一些寄存器和缓存器，用来保存数据。当CPU要使用数
1_顺序表_
10-02
基于顺序存储结构的图书信息表的创建和输出描述定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。...
2_顺序表_
10-01
基于顺序存储结构的图书信息表的修改描述定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据完成图书信息表的创建，然后计算所有图书的平均价格，将所有低于平均价格的图书价格提高20%，所有...
C++实现动态顺序表
08-19
"C++实现动态顺序表" C++中实现动态顺序表是指使用C++语言来实现一个可以动态变化的顺序表结构。这种结构可以根据需要动态地分配和释放内存，从而提高程序的效率和灵活性。 在C++中，使用动态顺序表可以通过使用...
线性表之顺序表
03-28
数据结构之顺序表，建表、查询、插入、删除，所有的过程
数据结构：3.3.3层序遍历
Aufidius的博客
06-16 165
用堆栈来保存：自己或者右儿子（在堆栈里实现的是保存自己这个结点）。用堆栈保存的过程：自己访问完了访问左儿子，把自己保存起来，这样将来回来的时候可以去访问右儿子。二叉树转为一维序列过程中的一个问题：一个结点只关联两个结点，访问了其中的一个另一个怎么办，另一个要把它存起来。如果不访问父亲结点是访问不到左儿子和右儿子的，如果把父亲忘了左右儿子也是找不到的。用队列来保存：保存的是未来要访问的结点（也就是右儿子结点）。二叉树的核心问题：把二维的结构变为一维的线性序列。采用不同的方法就会产生不同的一维的序列。
数据结构之B树的理解与示例（C#）
最新发布
qq_35320456的博客
06-19 957
B树在文件存储和处理中的应用是通过文件系统的目录结构来演示的。例如，当您在文件系统中创建一个新文件或目录时，操作系统会使用B树来决定如何在磁盘上存储这些数据，以及如何快速地定位和访问它们。在数据库中，B树或其变体B+树用于创建索引，以便快速检索表中的记录。当您对数据库执行查询时，B树索引可以帮助数据库快速定位到包含您所需数据的记录。总结来说，B树是一种强大的数据结构，它在C#中的应用广泛，无论是在数据库、文件系统还是其他需要高效存储和访问的场景中。
北航第六次数据结构与程序设计作业（查找与排序）选填题
zxy13149285776的博客
06-16 1134
但是我们可以根据满二叉树h=log（n+1）大概估计一下，如果是三层的满二叉树，那么n为7，如果是4层的满二叉树，则n为15。的次数，而不是18交换的次数，18先和10比较，发现18比10大。从arr[1]到arr[n-1]，如果本身就递增，那么每个元素只跟自己的直接前驱元素比较一次就行，那么比较了n-1次。发生冲突，说明余数一致，说明能整除，放眼观去，63,9,45都能整除，因此3个和18冲突。看好了，是在序列中的位置，不是下标，位置从1开始，下标从0开始。若查找一个不存在的元素，说明进行了深度次比较。
数据结构：树的同构
Aufidius的博客
06-18 350
基本的存储用数组，把需要的结点信息存储在数组中， 但左右儿子用类似链表的方式来表示 ，有一个 数据来指示左儿子右儿子在哪里。数组里的每个分量是一个结构， 每一列是数组的一个分量，这是一个结构。NULL在stdlb.h中的定义是0，空指针是0，它的值实际上是0，在这里不能有NULL（因为0也是下标！因为这种表示方法的灵活性，所以它具有链表的灵活性，但是它是使用数组进行表示的，所以称为“静态链表”数组正常的下标是从0开始的，怎么表示指向一个空的结点？二叉树的表示不是唯一的，且ABCD的顺序可以改变。
c语言顺序表合并顺序表
10-12
顺序表合并可以采用类似归并排序的思想，先将两个顺序表中的元素按照大小顺序合并到一个新的顺序表中，再将新的顺序表复制回原来的顺序表中。具体实现可以参考以下代码： ```c #include #include #define ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Peace & Love487

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值