数据结构笔记 四：顺序表

最新推荐文章于 2023-11-18 12:28:20 发布
最新推荐文章于 2023-11-18 12:28:20 发布
阅读量539 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OnlyLove_/article/details/120731757
版权

说明：本笔记依照《王道论坛-数据结构》视频内容整理。

一、定义

顺序表：用顺序存储的方式实现线性表。

顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间关系由存储单元的邻近关系来体现。

二、顺序表实现

1、静态分配

使用数组方式实现。

#define MAXSIZE 10          			// 定义最大长度
typedef int ElemType;					// 根据实际情况定义

typedef struct{
	ElemType data[MAXSIZE]; 	        // 用数组存放数据元素（ElemType - 实际数据类型）
	int length;             			// 顺序表的当前长度
}ListT;									// List（列表）T（数据类型）Q（指针类型）

typedef ListT* ListTQ;

1、静态分配表长无法更改。设置小了空间不够，设置大了浪费空间。

2、动态分配

#define MAXSIZE 10		// 顺序表的初始长度
typedef int ElemType;	// 根据实际情况定义

typedef struct{
	ElemType *data;		// 指示动态分配数组的指针（ElemType - 实际数据类型）
	int MaxSize;		// 顺序表的最大容量
	int length;			// 顺序表的当前长度
}ListT;					// List（列表）T（数据类型）Q（指针类型）

typedef ListT* ListTQ;

1、动态分配表长可以更改，因此需要一个变量指示最大容量。

2、在 C 语言中使用 malloc() 进行分配空间，free() 进行释放空间。

三、静态分配操作实现

1、InitList(&L)

void initList(ListT *l)
{
	for (int i = 0; i < MAXSIZE; i++) {
		l->data[i] = 0;		// 将所有元素设置为默认初始值
	}
	l->length = 0;			// 顺序表初始长度为0 
}

如果不进行初始化，顺序表静态分配可以会有脏数据（和静态分配位置有关，局部变量会出现这种情况）。
在这里插入图片描述

2、DestroyList(&L)

变量程序启动后自动分配，不可以进行销毁。

3、ListInsert(&L,i,&e)

/****************************************
* l - 要操作顺序表首地址
* i - 插入位置（注意位序和数组下标的关系、检查下标合法性）
* e - 插入元素
* 注：
* 	1、注意表满的情况
*	2、进行处理是只用元素位序进行考虑，数据移动时才需要考虑数组下标
* 时间复杂度：O(n)
****************************************/
int listInsert(ListT *l, int i, ElemType e)
{
	if (i<1 || i>l->length + 1) return 1;		// 插入位置错误
	if (l->length >= MAXSIZE) return 1;			// 存储空间满
	for (int j = l->length; j >= i; j--) {		// j 表示现有长度
		l->data[j] = l->data[j - 1];			// 第i元素后数据后移
	}
	l->data[i - 1] = e;							// 将e存放到第i位置
	l->length++;								// 长度加 1
	return 0;
}

在这里插入图片描述

4、ListDelete(&L,i,&e)

/****************************************
* l - 要操作的顺序表首地址
* i - 删除位置（注意位序和数组下标的关系）
* e - 保存删除位置的数据内容（用于从函数返回数据）
* 时间复杂度：O(n)
****************************************/
int listDelete(ListT *l, int i, ElemType *e)
{
	if (i<1 || i >l->length) return 1;			// 判断 i 的范围是否有效
	*e = l->data[i - 1];						// 将被删除的元素赋值给e
	for (int j = i; j < l->length; j++) {		// 使用 i 进行计算，不定义 j 也可以
		l->data[j - 1] = l->data[j];			// 将第 i 位置后的元素前移
	}
	l->length--;								// 线性表长度减 1

	return 0;
}

在这里插入图片描述

5、LocateElem(L,e)

/****************************************
* l - 要操作的顺序表首地址
* e - 要查找的值
* 注：不适用于结构类型（因为不可以直接比较数据）
****************************************/
int locateElem(ListT *l, ElemType e)
{
	for (int i = 0; i < l->length; i++) {
		if (l->data[i] == e) return i + 1;	// 数组下标为i的元素值等于e，返回其位序i+1（注意位序和数组下标关系）
	}

	return 0;								// 查找失败，返回0
}

6、GetElem(L,i)

/****************************************
* l - 要操作的顺序表首地址
* i - 查找位置
****************************************/
ElemType getElem(ListT *l, int i)
{
	if (i<1 || i>l->length) return 0;			// 判断 i 的范围是否有效

	return l->data[i - 1];						// 返回下标为 i 的数据内容
}

7、Length(L)

int length(ListT *l)
{
	return l->length;
}

8、PrintfList(L)

/****************************************
* l - 要操作的顺序表首地址
* 注：不同数据类型使用打印语句不同
****************************************/
void printfList(ListT *l)
{
	printf("l->length = %d\n",l->length);
	for(int i = 0; i < l->length; i++){
		printf("l->data[%d] = %d\n",i,l->data[i]);
	}
}

9、Empty(L)

int enpty(ListT *l)
{
	if(l->length == 0) return 0;
	else return 1;
}

四、静态分配和动态分配之间关系

静态分配内存布局图：
在这里插入图片描述
动态分配内存布局图：
在这里插入图片描述
静态分配中：顺序表存储空间首地址 - L.data。

动态分配中：顺序表存储空间首地址 - L.data

总结：静态分配和动态分配除使用空间在内存中布局不同，因此操作处理基本相同。

五、动态分配操作实现

1、InitList(&L)

void initList(ListT *l)
{
	l->data = (ElemType*)malloc(MAXSIZE*sizeof(ListT)); // 分配一片连续空间
	l->length = 0;                                      // 使用长度设置为0
	l->maxSize = MAXSIZE;                               // 设置最大长度
	for (int i = 0; i < l->maxSize; i++) {
		l->data[i] = 0;                                 // 分配空间清零
	}
}

在这里插入图片描述

2、IncreaseSize（特有）

void increaseSize(ListT *l, int len)
{
	ElemType *p = l->data;                                         	// 使用局部变量指向当前空间
	l->data = (ElemType *)malloc((l->maxSize + len)*sizeof(ListT));	// 新分配一片空间
	for (int i = 0; i < l->length; i++) {
		l->data[i] = p[i];                                      	// 将旧空间数据拷贝到新空间
	}
	l->maxSize = l->maxSize + len;                              	// 更改最大长度值
	free(p);                                                    	// 释放旧空间
}

// realloc 库函数实现以上过程

在这里插入图片描述

3、DestroyList(&L)

/****************************************
* l - 要操作的顺序表首地址
* 注：只可以释放使用 malloc 分配的部分（不释放会引起内存泄漏）
****************************************/
void DestroyList(ListT *l)
{
	if(l->data != NULL){
		free(l->data);
		l->data = NULL;
		l->maxSize = 0;
		l->length = 0;
	}
}

4、ListInsert(&L,i,&e)

/****************************************
* l - 要操作顺序表首地址
* i - 插入位置（注意位序和数组下标的关系、检查下标合法性）
* e - 插入元素
* 注：
* 	1、注意表满的情况
*	2、进行处理是只用元素位序进行考虑，数据移动时才需要考虑数组下标
* 时间复杂度：O(n)
****************************************/
int listInsert(ListT *l, int i, ElemType e)
{
	if (i<1 || i>l->length + 1) return 1;		// 插入位置错误
	if (l->length >= l->maxSize) return 1;		// 存储空间满(和静态分配有区别)
	for (int j = l->length; j >= i; j--) {		// j 表示现有长度
		l->data[j] = l->data[j - 1];			// 第i元素后数据后移
	}
	l->data[i - 1] = e;							// 将e存放到第i位置
	l->length++;								// 长度加 1
	return 0;
}

5、ListDelete(&L,i,&e)

/****************************************
* l - 要操作的顺序表首地址
* i - 删除位置（注意位序和数组下标的关系）
* e - 保存删除位置的数据内容（用于从函数返回数据）
* 时间复杂度：O(n)
****************************************/
int listDelete(ListT *l, int i, ElemType *e)
{
	if (i<1 || i >l->length) return 1;			// 判断 i 的范围是否有效
	*e = l->data[i - 1];						// 将被删除的元素赋值给e
	for (int j = i; j < l->length; j++) {		// 使用 i 进行计算，不定义 j 也可以
		l->data[j - 1] = l->data[j];			// 将第 i 位置后的元素前移
	}
	l->length--;								// 线性表长度减 1

	return 0;
}

6、LocateElem(L,e)

/****************************************
* l - 要操作的顺序表首地址
* e - 要查找的值
* 注：不适用于结构类型（因为不可以直接比较数据）
****************************************/
int locateElem(ListT *l, ElemType e)
{
	for (int i = 0; i < l->length; i++) {
		if (l->data[i] == e) return i + 1;	// 数组下标为i的元素值等于e，返回其位序i+1（注意位序和数组下标关系）
	}

	return 0;								// 查找失败，返回0
}

7、GetElem(L,i)

/****************************************
* l - 要操作的顺序表首地址
* i - 查找位置
****************************************/
ElemType getElem(ListT *l, int i)
{
	if (i<1 || i>l->length) return 0;			// 判断 i 的范围是否有效

	return l->data[i - 1];						// 返回下标为 i 的数据内容
}

8、Length(L)

int length(ListT *l)
{
	return l->length;
}

9、PrintfList(L)

/****************************************
* l - 要操作的顺序表首地址
* 注：不同数据类型使用打印语句不同
****************************************/
void printfList(ListT *l)
{
	printf("l->length = %d\n",l->length);
	for(int i = 0; i < l->length; i++){
		printf("l->data[%d] = %d\n",i,l->data[i]);
	}
}

10、Empty(L)

int enpty(ListT *l)
{
	if(l->length == 0) return 0;
	else return 1;
}
lqonlylove
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
超详细的数据结构---顺序表的有关教程
m0_64365419的博客
10-20 832
顺序表的概念，特点，以及如何用代码实现，基本操作和基本操作的时间复杂度；
数据结构笔记：单向链表
12-22
原文地址 分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'achar' a = b # 在python中，所有的变量保存的都是值的地址（就相当于c语言中的指针） # 等号右边表示执行，=b中的b就是执行，根据值的地址取到b的值，就成了a=20，而这时的操作，是把20的地址返给a；也因此，在python中，之前给a的字符串变量可以在之后换成int的变量，这次其他语言中是不能实现的。 # 等号实质上是改变了数据指向
【数据结构】第2章 线性表
Quentin的博客
04-19 286
2.1 线性表的定义和基本操作 线性表：线性表是具有相同（每个数据元素所占空间一样大）数据类型的n(n>0)n(n>0)n(n>0)个数据元素的有限序列（有次序），其中nnn为表长，当n=0n=0n=0时线性表是一个空表。若用LLL命名线性表，则其一般表示为： L=(a1,a2,…,ai,ai+1,…,an) L=(a_1,a_2,\dots,a_i,a_{i+1},\dots,a_n) L=(a1​,a2​,…,ai​,ai+1​,…,an​) 例：所有的整数按递增次序排列，是线性表吗
【数据结构初阶】顺序表
m0_70811813的博客
10-26 1958
顺序表的定义、顺序表的分类、动态顺序表的实现
数据结构C语言-线性表的定义、销毁及增删改查（数据运算）
T1cH9的博客
05-26 1279
声明部分： #include <stdio.h> #include <stdlib.h> #define INIT_SIZE 1 #define BOLCK_SIZE 10 typedef struct { int *data; int length; int MaxSize; } SqList; SqList CreateListInt(); //创建线性表 void DestoryList(SqList *L); //销毁线性表 void Inc
cpp学习笔记：STL list容器
ohhjack的博客
11-18 570
cpp
7-2 数据结构实验一 顺序表的插入
最新发布
qq_54405966的博客
11-18 958
以顺序表作存储结构，实现线性表的创建、插入。顺序表的类型描述。
数据结构—顺序表的基本操作--C语言代码（可运行）
qq_45066397的博客
08-21 3029
1、顺序表的基本操作 使用软件：vs code 基本操作： InitList(SqList*L);//初始化 Length(SqList&L);//求表长 ListInsert(SqList&L,inti,Elemtypee);//插入操作 ListDelete(SqList&L,inti,Elemtypee);//删除操作 LocateElem(SqList&L,Elemtypee);//按值查找 GetElem(SqList&...
数据结构基础代码3：在顺序表L的第i位置插入新元素e
xiuhhhua的博客
07-31 4198
本次的代码主要思路就是通过指针传入线性表（为何使用指针详情见后续更新或通过百度），传入position，value值，将线性表内的position后的数值依次向后移动，直到将position的位置的元素复制到position+1的位置，后为position赋值value。代码块中的printflist（）函数仅仅是为了方便输出，多次调用减少代码量写的。重点是要将线性表的length+1！...
数据结构——顺序表
qq_62644791的博客
04-25 974
在数据结构中，线性表也被称为顺序表，其定义为由n个数据特性相同的元素构成的有限序列。在这里将会对顺序表的相关操作进行代码展示和思路解答，希望能够得到各位猿猿的采纳（不足之处欢迎指正）！ 第一步，需要对顺序表进行初始化 顺序表的初始化操作就是构造出一个空的顺序表 typedef struct SequentialList { int actualLength; int data[LIST_MAX_LENGTH]; //The maximum length is fixed. } *S
数据结构笔记：栈
01-20
分类目录——数据结构笔记](https://blog.csdn.net/bbjg_001/category_9753496.html) 栈（stack），有些地方也成为堆栈，是一种容器，可存储元素、访问元素、删除元素，他的特点是值能允许在容器的一段（称之为 栈顶...
数据结构笔记：二分查找
12-22
分类目录——数据结构笔记 只能作用于有序的顺序表上 又折半查找 对比序列的中间值，小于该值从左序列中二分查找，大于该值从右序列中二分查找，直到查找到目标值或子序列只有一个元素截止 实现 递归实现 def binary...
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
数据结构 顺序表 源码
10-14
本人正在学习中，小小的坐笔记，自己起后备用的哈哈，其实不完整 ，只是小小的实现下功能，认识下顺序表的结构
C++之顺序表：为啥你写的代码有脏数据？
专业^团队的博客
09-04 524
1.如果对于一个顺序表在初始化的时候不给他赋值初始化，他将会变得一发不可收拾.jpg 现在声明一个线性表（顺序表），并且初始化其长度，但并未赋初值，会有什么后果呢？ #include<stdio.h> #define MaxSize 10 typedef struct { int data[MaxSize]; int length;//表长 }SqList; void InitList(SqList& L) { /* //赋初值，可省略，但会产生"脏数据" for(int i
线性表初始化
weixin_62288150的博客
03-13 644
顺序表一定要初始化！！！不然会导致线性表输出与输入对应不上，没有输出 顺序表在输入函数时，传参要用引用，输出函数不需要
6-4 数据结构考题 - 直接插入排序
国家一级致癌物
11-30 2000
6-4 数据结构考题 - 直接插入排序 (25 分) 用顺序表作存储结构，输入一组数据，用直接插入法对其进行排序。 顺序表的类型描述： #define MAXSIZE 50 // MAXSIZE为最大数据元素数目 typedef int ElemType; typedef struct { ElemType r[MAXSIZE +1]; // r[0]闲置或另作它用 int length; }SqList; 函数接口定义： 下面给出了 直接插入排序 函数的大部分内容，但缺少了一部
数据结构---顺序表
方池安夏的博客
03-06 842
目录顺序表原理顺序表的算法实现顺序表的初始化顺序表增加元素顺序表插入元素顺序表删除元素顺序表销毁顺序表遍历完整代码 顺序表原理 顺序表是简单的一种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以 快速定位第几个元素，中间不允许有空值，插入、删除时需要移动大量元素。 顺序表的三个要素： 用elems记录存储位置的基地址 分配一段连续的存储空间size 用length记录实际的元素个数，即顺序表的长度 顺序表的算法实现 顺序表的初始化 #include <stdio.h> #
数据结构-List
qq_44792820的博客
06-21 403
#include <stdio.h> #include <stdlib.h> #define Maxsize 10 //定义线性表结构 //1.静态存储 typedef struct{ int data[Maxsize]; //用静态的“数组”存放数据 ElemType->int int length; //表示顺序表当前的长度 }SqList; void InitList(SqList &L){ for(int i
数据结构顺序表前插法
09-03
数据结构中的顺序表是一种线性结构，它使用物理地址连续的存储单元按顺序存储数据元素，通常使用数组来实现。在顺序表上进行前插法操作时，需要将要插入的数据元素放在表的前面，并调整其他元素的位置。 顺序表的前...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值