02_线性表_顺序表

最新推荐文章于 2024-07-25 15:54:48 发布
最新推荐文章于 2024-07-25 15:54:48 发布
阅读量63 收藏 1
点赞数 1
分类专栏： # 数据结构 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48083892/article/details/125356397
版权

2 线性表

线性表：（顺序表，单链表，静态链表，栈，队列，串）
有唯一的头，有唯一的尾；其他任意一个节点都有一个直接前驱和一个直接后继

顺序表： 逻辑相邻物理也相邻（类似一维数组）但是和数组有区别
顺序表与数组的区别：

数组只支持2个操作：向数组中放数据，从数组中取数据，一维数组是一个特殊的顺序表

顺序表支持多种操作：插入，删除…
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
问题： 向顺序表中插入数据需要挪动其位置后的数据，但是如何判断其位置后有没有数据

普通解决方法： C语言中只能判断变量中是否有值，不能判断是否是有效值；
(1) ’ \0’ 是字符串结束的标志，故只能用来判断字符串
(2) arr[i] ! = 0 ;若用此方法，则’ 0 '表示无效值，数组中不能存放有效值 ‘ 0 ’
正确解决方法： 此时需要人为的加入一个标记：定义一个计算器，记录有效数据的个数
在这里插入图片描述

2.1 顺序表：适合查询

2.1.1 定长顺序表

在这里插入图片描述


//顺序表，固定长度：非常简单，但是不实用
typedef struct SQList//把一种数据类型起一种新的别名为SQList
{
	int elem[10];//存放数据，固定长度为10
	int length;//有效数据的个数;此时插入数据时物理位置必须连续，无论插入多少个数据,length始终为一个数字，故空间复杂度为O(1);
               //若插入数据时不连续，则每插入一个数据都要有标记。此时空间复杂度为O（n）;
}SQList,
*PSQList;//结构体指针：
//等价于  typedef struct SQList* PSQList;结构体指针起个别名叫PSQList


//初始化
void InitSqList(PSQList ps)//PSQList==SQList *
{
	assert(ps != nullptr);//断言只在Debug模式下有效：Debug是程序员开发版本，有调试信息
	if (ps == nullptr)    //在Release模式下依然有效：Release是发行版本，代码优化过，编译器自动删除了所有调试信息
	{
		return;
	}
	ps->length = 0;//有效数据个数为0，故不需要将数组中10个元素初始化为0；
}

//判断被插入数组是否满
static bool IsFul(PSQList ps)
{
	return ps->length == 10;
}

//在ps顺序表的pos位置标插入数据val
//插入的数据必须左边连续
void Insert(PSQList ps, int pos, int val)
{
	assert(ps != nullptr);//断言只在Debug模式下有效：Debug是程序员开发版本，有调试信息
	if (ps == nullptr)    //在Release模式下依然有效：Release是发行版本，代码优化过，编译器自动删除了所有调试信息
	{
		return ;
	}
	if (pos<0 || pos>ps->length|| IsFul(ps))
	{
		return ;
	}
	//移动后面的数据
	for (int i = ps->length - 1;i >= pos;i--)
	{
		ps->elem[i + 1] = ps->elem[i];
	}
	//插入新的数据
	ps->elem[pos] = val;
	//有效数据个数+1；
	ps->length += 1;

}

//输出顺序表
void Show(PSQList ps)
{
	for (int i = 0;i < ps->length;++i)
	{
		printf("%d", ps->elem[i]);
		printf(" ");
	}
	printf("\n");
}

//判空
bool IsEmpty(PSQList ps)
{
	return ps->length == 0;
	/*if (ps->length == 0)
	{
		return true;
	}*/
}

//在ps中查找第一个key,找到了返回下标，没有找到返回-1
int Search(PSQList ps, int key)
{
	for (int i = 0;i < ps->length;i++)
	{
		if (key == ps->elem[i])
		{
			return i;
		}
		return -1;
	}
}


//在ps中查找第一个key,找到了返回下标，没有找到返回-1
int Search(PSQList ps, int key)
{
	/*for (int i = 0;i < ps->length;i++)
	{
		if (key == ps->elem[i])
		{
			return i;
		}
		return -1;
	}*/

	/*int pos = -1;
	int i = 0;
	while (i < ps->length && key != ps->elem[i])
	{
		i++;
	}
	if (i < ps->length)
	{
		pos = i;
	}
	
	return pos;*/

	int pos = ps->length - 1;
	while (pos>=0 && key != ps->elem[pos])
	{
		--pos;
	}
	return pos;
}


//删除pos位置的值
bool DelPos(PSQList ps, int pos)
{
	//判断pos位置是否合法
	if (pos < 0 || pos >= ps -> length)
	{
		return false;
	}
	//将后面的数据前移
	//for (int i = pos;i < ps->length;i++)
	for (int i = pos;i < ps->length-1;i++)
	{
		ps->elem[i] = ps->elem[i + 1];//遇见i+1需要考虑越界
	}
	ps->length--;
	return true;
}

//删除第一个val值
bool DelVal(PSQList ps, int val)
{
	int i = Search(ps, val);
	if (i < 0)
	{
		return false;
	}
	return DelPos(ps, i);
}

//返回key的前驱下标，如果不存在返回-1；
int GetPrio(PSQList ps, int key)
{
	int i = Search(ps, key);
	if (i <= 0)//注意头没有前驱
	{
		return-1;
	}
	return i - 1;
}

//返回key的后继下标，如果不存在返回-1；
int GetNext(PSQList ps, int key)
{
	int i = Search(ps, key);
	if (i< 0 || i==ps->length - 1)//注意尾巴也没有后继
	{
		return-1;
	}
	return i + 1;
}

//清空数据
void Clear(PSQList ps)
{
	ps->length = 0;
}

//销毁整个内存(动态内存)
void Destory(PSQList ps)
{
	Clear(ps);//此例子没有开辟动态内存
}
2.1.2 不定长顺序表

在这里插入图片描述
类型改变如下：
在这里插入图片描述
顺序表冒泡排序
在这里插入图片描述
代码优化：若数据本身就有序，直接退出循环
在这里插入图片描述

//顺序表，长度不固定（容量满了可以自动增长）
typedef struct DSQList//把一种数据类型起一种新的别名为SQList
{
	int* elem;//动态内存的地址，因为用malloc,所以返回就是一个地址，想存一个整型值，数组存放整型值，所以返回一个整型的指针
	//书上定义的是ElemType*elem;目的是为了解决泛型（int，char...)
	//C语言解决泛型用：函数指针；C++解决泛型用：模板
	int length;//有效数据的个数;
	int listsize;//总容量
}DSQList,
* DPSQList;//结构体指针：
//等价于  typedef struct DSQList* DPSQList;结构体指针起个别名叫DPSQList

//初始化,动态创建初始容量
void InitDSqList(DPSQList ps)
{
	assert(ps != nullptr);
	if(ps==nullptr)
	{
		return;
	}
	ps->elem = (int*)malloc(INIT_SIZE * sizeof(int));//对比STL中容器的初始化为0
	ps->length = 0;//有效数据个数
	ps->listsize = INIT_SIZE;//总容量
}

//判断被插入数组是否满
static bool IsFul(DPSQList ps)//内部使用不对外提供服务故为静态函数
{
	return ps->length == INIT_SIZE;
}

//容量增长函数，容量变为原来的2倍（STL中有可能是2倍或1.5倍）
//1.5倍更好。因为当前面的空间释放之后，后面重新申请空间时可以利用到前面释放的空间
// 10 15 23 35 53 ... 当第2次扩容申请23个空间时就可以利用前面释放的10+15=25个空间（如果空间连续的话）

//10 20 40 ... 如果扩容2倍，前面释放的空间无法重新利用
static bool Inc(DPSQList ps)
{
	ps->elem = (int*)realloc(ps->elem, ps->listsize * 2 * sizeof(int));
	assert(ps->elem != NULL);
	ps->listsize *= 2;
	//ps->length;不变
	return true;
}
//在ps顺序表的pos位置标插入数据val
bool Insert(DPSQList ps, int pos, int val)
{
	if (pos<0 || pos> ps->length)
	{
		return false;
	}
	if (IsFul(ps))
	{
		Inc(ps);
	}
	//移动后面的数据
	for (int i = ps->length - 1;i >=pos;i--)
	{
		ps->elem[i + 1] = ps->elem[i];
	}
	//插入新的有效数据
	ps->elem[pos] = val;
	//有效数据个数+1
	ps->length++;
	return true;
}

//判空
bool IsEmpty(DPSQList ps)
{
	return ps->length == 0;
}

//在ps中查找第一个key,找到了返回下标，没有找到返回-1
int Search(DPSQList ps, int key)
{
	for (int i = 0;i < ps->length;i++)
	{
		if (key == ps->elem[i])
		{
			return i;
		}
		
	}
	return -1;
}

//删除pos位置的值
bool DelPos(DPSQList ps, int pos)
{
	//判断pos位置是否合法
	if (pos < 0 || pos >= ps->length)
	{
		return false;
	}
	//将后面的数据前移
	//for (int i = pos;i < ps->length;i++)
	for (int i = pos;i < ps->length - 1;i++)
	{
		ps->elem[i] = ps->elem[i + 1];//遇见i+1需要考虑越界
	}
	ps->length--;
	return true;
}

//删除第一个val值
bool DelVal(DPSQList ps, int val)
{
	int i = Search(ps, val);
	if (i < 0)
	{
		return false;
	}
	return DelPos(ps, i);
}

//删除所有val值
bool Del_All_Val(PDSQList ps, int val)
{
	int i, j = 0;
	while (j < ps->length)
	{
		if (ps->elem[j] != val)
		{
			ps->elem[i] = ps->elem[j];
			++i;
		}
		++j;
	}
	ps->length = i;
}

//返回key的前驱下标，如果不存在返回-1；
int GetPrio(DPSQList ps, int key)
{
	int i = Search(ps, key);
	if (i <= 0)//注意头没有前驱
	{
		return-1;
	}
	return i - 1;
}

//返回key的后继下标，如果不存在返回-1；
int GetNext(DPSQList ps, int key)
{
	int i = Search(ps, key);
	if (i < 0 || i == ps->length - 1)//注意尾巴也没有后继
	{
		return-1;
	}
	return i + 1;
}

//输出顺序表
void Show(DPSQList ps)
{
	for (int i = 0;i < ps->length;++i)
	{
		printf("%d", ps->elem[i]);
		printf(" ");
	}
	printf("\n");
}

//清空数据
void Clear(DPSQList ps)
{
	ps->length = 0;
}

//销毁整个内存
void Destory(DPSQList ps)
{
	free(ps->elem);
	ps->elem = NULL;//ps->elem==(*ps).elem
	ps->length = 0;
	ps->listsize = 0;
	ps = NULL;//无效代码
}

在这里插入图片描述
ps = NULL;为何为无效代码
因为将 ps 置空，仅仅改变了ps指向，并没有解引用（* ps）,所以指针 elem 指向的顺序表并没有销毁

顺序表的特点：
1.插入数据的时间复杂度是O（n);如果是尾插时间复杂度是O（1）

	for (int i = ps->length - 1;i >=pos;i--)
	{
		ps->elem[i + 1] = ps->elem[i];
	}

2.删除数据的时间复杂度是O（n);如果是尾删时间复杂度为O（1）
3.通过下标访问数据，时间复杂度为O（1）
4.简单

在这里插入图片描述

听*雨声
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表概念_线性表的顺序表表示和实现_线性表的顺序存储
diviner_s的博客
01-15 4900
线性表基础概念，线性表的顺序表表示和实现 线性表 线性表（linear list）是最基本、最简单、也是最常用的一种数据结构。线性表是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 特征 线性表是具有相同特征的数据元素的一个有限序列。 线性表（linear list）由n（n>=0）个数据元素（结点）a1，a2，…，an组成的有限序列 线性表中元素的个数n（n...
JAVA顺序表逆置算法_线性表顺序存储-练习题3-逆置顺序表
weixin_42361666的博客
02-25 1669
题目：以顺序表作存储结构实现线性表，实现就地逆置算法，即在原表的存储空间将线性表(a1, a2, ..., an)逆置为(an, ... , a2, a1).思路：需要考虑的线性表个数的奇/偶数情况，奇/偶数情况不同，置换的步伐长度不同设置一个中转数，当做数置换时做中转存储代码：#include #include #define MAXSIZE 101typedef struct {int r[M...
顺序表的c语言结构体描述,用C语言描述数据结构_线性表_顺序表
weixin_42524499的博客
05-22 1260
顺序表的概念和运算- 什么是线性表线性表是由n个元素(结点)组成的有限序列。n为线性表的长度，n=0时称为空表。- 线性表的逻辑特征(1)对于非空的线性表，有且有一个开始结点，它没有直接前驱，而仅有一个直接后继。(2)对于非空的线性表，有且有一个终端结点，它没有直接后继，而仅有一个直接前驱。(3)对于非空的线性表，内部结点(除去开始结点和终端结点)都有且仅有一个直接前驱和一个直接后继。- 图示 -...
线性表_顺序表
SalamAbdu的博客
03-18 241
线性表 上一个博文大概的介绍了线性表概念以及相关操作。本文主要介绍最简单的线性表结构——顺序表。 线性表的顺序存储结构_顺序表 顺序存储：采用顺序存储结构的线性表简称顺序表(sequential list)。顺序表以计算机内存储位置表示数据元素间的逻辑次序关系，表中相邻的元素，逻辑关系上相邻的元素在物理位置上也相邻。因此通常可以用数组来存储顺序表。顺序表的C++语言描述如下： const int ...
线性表2：线性表的顺序表示
m0_67393619的博客
05-16 368
2.2.1 顺序表的定义 线性表的顺序存储又称顺序表。 它是用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻、第1个元素存储在线性表的起始位置，第i个元素存储位置后面紧接着的是第i+1个元素，称i为元素ai在线性表中的位序。 顺序表的特点是： 表中元素的逻辑顺序与其物理顺序相同。 【注】：物理结构（存储结构）是数据结构在计算机中的表示。 每个数据元素的存储位置都和线性表的起始位置相差一个和该数据元素的位序成正比的常数，因此，线性表中的任一数据元素都可以随机
C语言_线性表之顺序表
01-16
线性表是最基础的数据结构之一，顺序表则是线性表的一种常见实现。本文将深入探讨C语言实现顺序表的相关知识点，包括其定义、操作以及具体实现。 顺序表是一种特殊的线性表，它的所有元素在内存中是连续存放的，...
line_map_线性表顺序排序_
10-01
总的来说，这个项目旨在提供一个基础的线性表顺序存储实现，通过自定义的动态数组类支持排序功能。开发者可以根据实际需求，扩展类的功能，优化排序算法，或加入更多数据结构操作，提高代码的灵活性和实用性。
12.zip_清除线性表_清除线性表L_顺序表
07-14
线性表可以是顺序表或链表等形式，而在这个例子中，由于提到了“顺序表”，我们可以推断出L是一个基于数组实现的线性表，即顺序存储结构。 顺序表是一种物理存储单元上连续的数据结构，它的特点是可以通过下标直接...
xianxingbiao.rar_线性表_线性表实习
09-19
在本实习项目“线性表_线性表实习”中，重点涉及的是链式结构的线性表，这是一种非顺序存储方式，与顺序表相比，链式结构具有更灵活的内存管理。 链式线性表由一系列节点组成，每个节点包含两部分：数据元素和指向...
xianxingbiao.rar_线性表 实验
09-14
2. 有序性：线性表中的元素按照一定的顺序排列，这种顺序可以是逻辑顺序或物理顺序。 线性表的主要操作： 1. 插入操作：在线性表的指定位置插入一个元素，这可能涉及到移动元素以腾出空间。 2. 删除操作：删除...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 166
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 236
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构---二叉树
weixin_47808575的博客
07-22 296
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 422
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 725
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构~~顺序表
TU^的博客
07-22 967
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
【数据结构】搜索二叉树
dab112的博客
07-24 1162
介绍了二叉搜索树的实现与模拟
数据结构：顺序表的实现
最新发布
2303_81073778的博客
07-25 236
3.test.c文件。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 461
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
线性表详解：顺序表与链表
1. 顺序存储：也称为顺序表，它将线性表的所有元素存储在一块连续的内存区域中。通过数组的方式，可以通过下标直接访问元素，具有较高的存取效率。例如，"0，1，2，…，9" 或 "A，B，C，…，Z" 可以看作是顺序表的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值