顺序表（定长的、扩容）

最新推荐文章于 2024-04-22 12:29:34 发布
最新推荐文章于 2024-04-22 12:29:34 发布
阅读量216 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57519884/article/details/120317540
版权

c语言

1、定长线性表

​ 相当于权限更多的数组，存在唯一的头（第一个节点），唯一的尾（最后一个节点），除了第一个有效节点，其余的节点都唯一有前驱节点，除了最后一个有效节点，其余的节点都有唯一后继节点。

请添加图片描述

//sqlist   sequence list
// 结构体的定义   函数的声明
#pragma once//保证程序制备编译器编译一次
//定长的顺序表结构体定义
typedef struct Sqlist
{
	int arr[10];//数据域
	int length;//有效数据节点的个数
}Sqlist, * PSqlist;
//typedef struct Sqlist Sqlist;
//typedef struct Sqlist* PSqlist;
//下面写可执行函数声明:
//不外乎增删改查

//初始化
void Init_sqlist(PSqlist plist);//struct Sqlist* plist

//按位置插入  
bool Insert_Pos(PSqlist plist, int pos, int val);

//按值删  删除这个值出现的第一次的位置
bool Del_val(PSqlist plist, int val);

//按位置删除
bool Del_pos(PSqlist plist, int pos);

//查找值为val的节点
int Search(PSqlist plist, int val);

//判空
bool IsEmpty(PSqlist plist);

//判满
bool IsFull(PSqlist plist);

//清空
void Clear(PSqlist plist);

//销毁
void Destroy(PSqlist plist);


#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include"Sqlist.h"//未在c语言函数库里的头文件需要用双引号
//typedef struct Sqlist Sqlist;
//typedef struct Sqlist* PSqlist;
//在头文件中已经定义
//初始化线性表
void Init_sqlist(PSqlist plist)//struct Sqlist* plist
{
	assert(plist != NULL);
	plist->length = 0;//由于已经在头文件里定义了
	return;
}
//按下标插入
bool Insert_Pos(PSqlist plist, int pos, int val)
{
	assert(plist != NULL);
	if (IsFull(plist))
	{
		return false;
	}
	if (pos<0 || pos>plist->length)
	{
		return false;
	}
	else
	{
		for (int i = plist->length-1; i >= pos; i--)//从插入的位置起将元素依次向后移,若是在最后一个插的话，for循环不成立
		{
			plist->arr[i + 1] = plist->arr[i];
		}
		plist->arr[pos] = val;
		plist->length++;
		return true;
	}
}
//按值删除这个值出现的第一次的位置
bool Del_val(PSqlist plist, int val)
{
	assert(plist != NULL);
	if (IsEmpty(plist))//
	{
		return false;
	}
	int pos=Search(plist, val);//通过寻找函数找出val的下标
	if (pos == -1)//如果没有找到，则return false
	{
		return false;
	}
	for (int i = pos; i < plist->length - 1; i++)
	{
		plist->arr[i] = plist->arr[i + 1];
	}
	plist->length--;
	return true;
}
//按下标删除
bool Del_pos(PSqlist plist, int pos)
{
	assert(plist != NULL);
	if (pos<0 || pos>plist->length - 1)
	{
		return false;
	}
	else
	{
		for (int i = pos; i < plist->length - 1; i++)
		{
			plist->arr[i] = plist->arr[i + 1];
		}
		plist->length--;
		return true;
	}
}
//查找值为val的节点
int Search(PSqlist plist, int val)
{
	assert(plist != NULL);
	for (int i = 0; i < plist->length; i++)
	{
		if (plist->arr[i] == val)
		{
			return i;
		}
	}
	return -1;
}
//判空
bool IsEmpty(PSqlist plist)
{
	assert(plist != NULL);
	if (plist->length > 0)
	{
		return false;
	}
	return true;
}
//判满
bool IsFull(PSqlist plist)
{
	assert(plist != NULL);
	if (plist->length == sizeof(plist->arr) / sizeof(plist->arr[0]))
	{
		return true;
	}
	return false;
}
//清空
void Clear(PSqlist plist)
{
	assert(plist != NULL);
	plist->length = 0;
}
//销毁
void Destroy(PSqlist plist)
{
	assert(plist != NULL);
	Clear(plist);
	plist = NULL;
}
void Print(PSqlist plist)
{
	assert(plist != NULL);
	for (int i = 0; i < plist->length; i++)
	{
		printf("%d ", plist->arr[i]);
	}
	printf("\n");
}
int main()
{
	Sqlist x = {};
	PSqlist p = &x;
	Init_sqlist(p);
	int ar[10] = { 12,23,34,45,56,67,78,89,90,100 };
	int n = sizeof(ar) / sizeof(ar[0]);
	for (int i = 0; i < n; i++)
	{
		Insert_Pos(p, i, ar[i]);
		Print(p);
	}
	for (int i = 9; i >= 0; i--)
	{
		Del_pos(p, i);
		Print(p);
	}
	Clear(p);
	printf("%d ", IsEmpty(p));
	Destroy(p);
}

2、不定长线性表

请添加图片描述

扩容原理：（recalloc()）

#pragma once
typedef int ELEM_TYPE;
#define INIT 10        //线性表初始长度
typedef struct DSqlist  //不定长线性表
{
	ELEM_TYPE* data;//用来承接malloc来的数组的地址
	int length;//当前数组的元素个数
	int listsize;//当前申请的数组可存放的元素个数
}DSqlist,*PDSqlist;
void Init_DSqlist(PDSqlist plist);//struct Sqlist* plist
//按位置插入  
bool Insert_Pos(PDSqlist plist, int pos, int val);

//按值删  删除这个值出现的第一次的位置
bool Del_val(PDSqlist plist, int val);

//按位置删除
bool Del_pos(PDSqlist plist, int pos);

//查找值为val的节点
int Search(PDSqlist plist, int val);

//判空
bool IsEmpty(PDSqlist plist);

//判满
bool IsFull(PDSqlist plist);

//清空
void Clear(PDSqlist plist);

//销毁
void Destroy(PDSqlist plist);

//扩容
void Dilatation(PDSqlist plist);

#include"DSqlist.h"
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>
/*
顺序表的特点：
1.简单  好实现
2.逻辑上相邻，物理上也相邻
3.插入时间复杂度O(n)(挪动数据)   尾插的时间复杂度为O(1)
4.删除时间复杂度O(n)(挪动数据)   尾删的时间复杂度为O(1)
5.随机访问时间复杂度O(1)   因为有数组下标帮忙
*/
void Init_DSqlist(PDSqlist plist)//struct Sqlist* plist
{
	assert(plist != NULL);
	plist->data = (ELEM_TYPE*)malloc(sizeof(int) * INIT);
	plist->length = 0;
	plist->listsize = INIT;
	return;
}
//按位置插入  
bool Insert_Pos(PDSqlist plist, int pos, int val)
{
	assert(plist != NULL);
	if (IsFull(plist))
	{
		Dilatation(plist);
	}
	for (int i = plist->length - 1; i >= pos; i--)
	{
		plist->data[i + 1] = plist->data[i];
	}
	plist->data[pos] = val;
	plist->length++;
	return true;
}
//按值删  删除这个值出现的第一次的位置
bool Del_val(PDSqlist plist, int val)
{
	assert(plist != NULL);
	if (IsEmpty(plist))
	{
		return false;
	}
	int pos = Search(plist, val);
	if (pos ==-1)
	{
		return false;
	}
	Del_pos(plist, pos);
}
//按位置删除
bool Del_pos(PDSqlist plist, int pos)
{
	assert(plist != NULL);
	if (IsEmpty(plist))
	{
		return false;
	}
	for (int i = pos; i < plist->length - 1; i++)
	{
		plist->data[i] = plist->data[i + 1];
	}
	plist->length--;
	return true;
}
//查找值为val的节点
int Search(PDSqlist plist, int val)
{
	assert(plist != NULL);
	for (int i = 0; i < plist->length; i++)
	{
		if (val == plist->data[i])
		{
			return i;
		}
	}
	return -1;
}
//判空
bool IsEmpty(PDSqlist plist)
{
	assert(plist != NULL);
	if (plist->length == 0)
	{
		return true;
	}
	return false;
}

//判满
bool IsFull(PDSqlist plist)
{
	assert(plist != NULL);
	if (plist->length == plist->listsize)
	{
		return true;
	}
	return false;
}

//清空
void Clear(PDSqlist plist)
{
	assert(plist != NULL);
	plist->length = 0;
	plist->listsize = 0;
	return;
}

//销毁
void Destroy(PDSqlist plist)
{
	assert(plist != NULL);
	Clear(plist);
	free(plist->data);
	plist->data = NULL;
	return;
}
//扩容
void Dilatation(PDSqlist plist)
{
	assert(plist!= NULL);
	plist->data = (ELEM_TYPE*)realloc(plist->data, sizeof(ELEM_TYPE)*plist->listsize*2);
	if (plist->data == NULL)
	{
		return;
	}
	plist->listsize *= 2;
}
void Print(PDSqlist plist)
{
	assert(plist != NULL);
	for (int i = 0; i < plist->length; i++)
	{
		printf("%d ", plist->data[i]);
	}
	printf("\n");
}


//扩容有三种可能，第一种，后面的内存可用，往后面添加
//第二种，后面的内存不够，重新创建新的
//第三种，所有内存都不够，返回false
int main()
{
	int ar[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int n = sizeof(ar) / sizeof(ar[0]);
	DSqlist x = {};
	PDSqlist p = &x;
	Init_DSqlist(p);
	for (int i = 0; i < n; i++)
	{
		Insert_Pos(p, i, ar[i]);
		Print(p);
	}
	Insert_Pos(p, 10, 11111);
	Print(p);
	Clear(p);
	Destroy(p);
}
ist->data[i]);
}
printf("\n");
}
//扩容有三种可能，第一种，后面的内存可用，往后面添加
//第二种，后面的内存不够，重新创建新的
//第三种，所有内存都不够，返回false
int main()
{
int ar[10] = { 1,2,3,4,5,6,7,8,9,10 };
int n = sizeof(ar) / sizeof(ar[0]);
DSqlist x = {};
PDSqlist p = &x;
Init_DSqlist§;
for (int i = 0; i < n; i++)
{
Insert_Pos(p, i, ar[i]);
Print§;
}
Insert_Pos(p, 10, 11111);
Print(p);
Clear(p);
Destroy(p);
}
0-1背包
关注
专栏目录
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表）
07-13
顺序表是一种线性结构，它的所有元素在内存中连续存放，可以分为静态顺序表和动态顺序表。静态顺序表通常是在编译时就预分配好固定大小的数组，而动态顺序表则可以根据需要动态地调整其容量。 静态顺序表的优点在于...
【上机实验】01：顺序表扩容
https://blog.csdn.net/m0_74834215
04-17 3097
顺序表扩容 程序=算法+数据结构 数据结构=结构定义+结构操作 程序设计=算法+数据结构+编程范式 1.顺序表操作： 注意：顺序表与数组的不同点在于顺序表支持动态扩容操作 #include<stdio.h> #include<stdlib.h> #include<time.h> typedef struct{ int *data; int size, length; }SqList; //1.顺序表初始化 SqList *init(int n)
顺序表及扩容
Huo_Chuanfei的博客
12-05 488
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <inttypes.h> #include <time.h> typedef struct Vector { int *data; int size; int length; } Vec; Vec *init(int n) { Vec *v = (Vec *)malloc(sizeof(Vec));
数据结构（扩容顺序表）
m0_56799144的博客
03-25 2083
1.1 顺序表的定义 线性表的顺序存储结构，指的是用一段地址连续的储存单元依次存储线性表的数据元素 所以我们需要一个数组来存放数据，一个整形来记录线性表当前长度，还有一个来记录当前线性表最大的存储量。 1.2 扩容顺序表的初始化 可扩容的顺序表相比与定长顺序表要多一个整型值来保存最大容量个数。 根据上图分析代码如下: typedef struct Dsqlist { int length; int list_size; ELEM_TYPE* data;//接受从堆内申请来的空..
002_可以自动扩容的顺序表
qq_22056419的博客
03-25 310
跟上篇文章的区别 仅仅在于。 上篇文章：001_顺序表的实现 我删除了限制，把增的部分改写成了这样： //增：在末尾添加一个数据 func (list *ArrayList)Append(v interface{})(error){ list.Data = append(list.Data, v) list.TheSize++ return nil } //增：在指定索引位置，插入数据 f...
顺序表(可扩容)
hutaomywife的博客
03-23 173
适用于需要大量随机访问数据元素，并插入和删除操作大都是在尾部进行的。数据删除方式，有四种(头删、尾删、按位置删、按值删)数据插入方式，有三种(头插、尾插、按位置插)头插头删，中间插入，中间删除，效率低。扩容代价高：申请，拷贝，释放。可扩容顺序表的优缺点。
如何实现顺序表的动态扩容
**介绍顺序表和动态扩容** 顺序表是一种基本的数据结构，通过一组连续的存储单元来存储数据元素。然而，静态顺序表在使用过程中存在容量固定、内存浪费、插入删除困难等问题。为了解决这些问题，引入了动态扩容的...
顺序表的动态扩容实现技巧
# 1. 理解顺序表 顺序表是一种线性表的存储结构，通过连续的内存空间来存储数据元素。在顺序表中，元素之间通过索引来确定...在接下来的章节中，我们将深入探讨顺序表的动态扩容原理以及相关的算法实现细节。 # 2.
如何实现顺序表的扩容
**介绍实现顺序表扩容的原因** 顺序表需要扩容的主要原因是在数据量动态变化时，原有内存空间无法满足数据存储需求。当顺序表空间不足时，会导致插入新元素时频繁执行内存重新分配和数据复制操作，降低程序性能。...
数据结构顺序表c语言扩容
最新发布
09-11
随着元素的增加，顺序表可能需要扩容以存储更多的数据。扩容通常意味着创建一个更大的数组，并将原数组中的所有元素复制到新的数组中，然后释放原数组的空间。 在C语言中实现顺序表的扩容一般遵循以下几个步骤： 1....
数据结构之顺序表构造、插入、扩容操作
qq_40022596的博客
04-26 2482
一、顺序表概述
顺序表（动态扩容）
m0_69886881的博客
09-01 462
含：顺序表的实现代码C语言版，每个相关函数的介绍
算法—顺序表之列表的扩容机制(python实现)
python全栈
11-10 1102
顺序表中增加元素 在尾部增加元素：时间复杂度为O(1) 在任意位置插入元素：时间复杂度为O(n) 顺序表中删除元素 删除尾部元素：时间复杂度为O(1) 删除任意位置元素：时间复杂度为O(n) PY_SSIZE_T_MAX=float('inf') #最大的容量 obj_size=1 class List: allocated=0 #容量默认为0 size=0 #元素个数默认为0 items=[] #数据区默认为空 def list_resize(self,
vertica 表空间扩容_顺序表的实现
weixin_42322782的博客
01-29 276
数据结构不仅仅指的数据值在逻辑上的结构，更有在存储空间上的位置结构，顺序表，故名思意是有一定顺序的数据结构。顺序表最基本模型如图：对于基本布局顺序表而言，它存储相同单元大小并且在内存地址上连续的数据，逻辑地址是其元素的逻辑顺序，物理地址第一个元素的内存地址加上离第一个元素的距离，如：e1物理地址是l0，那么e2的物理地址是e1的地址加上e1所占用的大小c，以此类推，en的物理地址是l0+（n-1）...
顺序表的增删改查等操作以及动态扩容
m0_51364183的博客
08-13 232
定义一个结构体: typedef struct SeqList { ElemType* base; size_t capacity; size_t size; }SeqList; 1.对数组初始化 void SeqListInit(SeqList* pst, size_t capacity) { pst->capacity = capacity; pst->base = (ElemType*)malloc(sizeof(ElemType) * pst->capacit
动态顺序表（可扩容）的基本操作
fern_girl的博客
04-24 1497
头文件：#define _CRT_SECURE_NO_WARNINGS 1 #ifndef _STATICSEQLIST_H__ #define _STATICSEQLIST_H__#include<stddef.h> #include<assert.h> #include<string.h> #include<stdlib.h> #include<stdio.h>#define MAXSIZE 1
【数据结构（C++）】顺序表（动态）基本操作（初始化，扩容，增删查改等操作）
qq_61953021的博客
04-22 338
需要注意的是扩容并不是在原空间的基础上再加一点空间，而是在其他位置分配一段连续的，大小足够的新空间，将数据都放在新空间，原空间释放掉。扩容流程为：1、分配一段连续的新空间，空间大小为扩容后的大小。动态分配顺序表总体和静态的没多大区别，就是随时可以进行扩容。3、释放原空间，将原空间指针指向新空间。2、将原空间的数据粘贴到新空间。
【数据结构】——顺序表的插入、扩容、删除、性能分析基础详解
VegetableGirl的博客
06-12 3822
1.1线性表的定义 线性表：是由n个数据元素组成的有限序列，记为 （a1，a2，……，ai，……，an） eg：英文字母表（a，b，c……z）是一个长度为26的线性表 问题1：线性表是否允许长度n=0? 答：是！（从实际出发，为什么要有数据结构？为什么要有线性表?——让我们存储元素的呀！当我们的元素还没有进入线性表的时候，n=0） 问题2：什么叫前驱/后继？每个元素都有前驱/后继吗？ 答：前驱——此元素前面的一个元素就是...
顺序表的基本操作（及动态扩容）
qq_40692598的博客
11-02 2360
顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。顺序表的存储特点是：只要确定了起始位置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值