数据结构初阶 -- 顺序表

已于 2023-03-01 15:43:02 修改
阅读量798 收藏 18
点赞数 7
分类专栏： c语言 文章标签： 数据结构 算法
于 2023-03-01 15:33:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71321720/article/details/129281595
版权

数据结构初阶 链表的讲解

目录

一. 线性表

1.1 定义

1.2 特点

二. 顺序表

2.1 定义

2.2 代码

2.3 功能需求

2.4 静态顺序表的特点以及缺点

2.5 动态的顺序表

2.6 动态顺序表接口的实现

三. 代码

头文件

主文件

一. 线性表

1.1 定义

  • 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
  • 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

看这个定义 我们再联想前面的知识

其实顺序表本质上就是数组

但是它在数组上增加了一点内容

1.2 特点

它分为静态的和动态的

这个特点和我们做的项目 通讯录 十分相似

它是连续存储的 不能跳过元素

二. 顺序表

2.1 定义

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

2.2 代码

struct SeqList
{
	int a[100];             //数组
	int size;               //数组中存储了多少个 
};

我们说类似这个结构的 就是一个顺序表

        但是 为了我们以后改变数字方便 我们可以把这里的100 定义成一个宏 这样我们以后如果想修改顺序表的大小 只要改变宏就可以了

代码表示如下

// 静态顺序表
#define N 100
struct SeqList
{
	int a[N];             //数组
	int size;             //数组中存储了多少个
};

同样的 我们想使用顺序表来管理一个字符串

#define N 100
struct SeqList
{
	char a[N];        
	int size; 
};

        我们可以改变int类型 变为char类型的数据 但是这样每次改也太麻烦了 所以我们依旧可以再上面定义一个宏变量

#define N 100
typedef char SLDateType

struct SeqList
{
	int SLDateType[N]; 
	int size; 
};

可以使用这样的格式 方便以后一次性改变所有的变量类型

但是 这样子我们看整个结构体还是有点麻烦 我们再将这个结构体简化一下

typedef struct SeqList
{
	int SLDateType[N]; 
	int size; 
}SL;

2.3 功能需求

        在创建好这个静态表之后 我们要开始大概创建它的一些功能

比如说以下的一些功能

vovoid SeqListInit(SL* ps);
void SeqListPushBack(SL* ps, SLDateType x);
void SeqListPopBack(SL* ps);
void SeqListPushFront(SL* ps, SLDateType x);
void SeqListPopFront(SL* ps);

2.4 静态顺序表的特点以及缺点

  • 特点： 如果满了就不让插入
  • 缺点： 不知道给多少合适

2.5 动态的顺序表

typedef struct SeqList
{
	SLDateType* a; 
	int size; 
	int capacity;
}SL;

跟我们的通讯录特别相似

其实原理本质上都是一样的

2.6 动态顺序表接口的实现

初始化

void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

尾插

​

  1.  没有空间
  2. 空间不够 扩容
  3. 空间足够

空间足够的情况

void SeqListPushBack(SL* ps, SLDateType x)
{
	ps->a[ps->size] = x;
	ps->size++;
}

代码表示如上

那么我们接下来我们写上面的两种情况

这里我们要注意的是 一开始我们将指针置空 占用的空间为0

所以说我们一开始至少要开始4个数据的空间 这里可以使用一个三目操作符解决

int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
void SeqListPushBack(SL* ps, SLDateType x)
{
	// 如果没有空间或者空间不足 我们就扩容 
	// 扩容失败就报错
	if ((ps->size)==(ps->capacity))
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLDateType* tmp =(SLDateType*)realloc(ps->a, newcapacity * sizeof(SLDateType));
		if (tmp==NULL)
		{
			perror("pushback realloc");
		}
	}

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

这里我们使用一个打印函数看看整个数据的内容

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

打印结果如下

​

 在使用完成之后我们还需要一个接口函数来释放我们的动态开辟的内存 从而避免内存泄漏的问题

void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a == NULL;
	ps->capacity = ps->size = 0;
}

接下来我们看尾删函数

void SeqListPopBack(SL* ps)
{
	ps->size--;
}

尾删的话其实我们只要将size-- 就可以

但是这里我们要注意一点 当size为0的时候 这里就不可以再删除了 所以我们还需要完善以下上面的代码

void SeqListPopBack(SL* ps)
{
	if (ps->size==0)
	{
		perror("SeqListPopBack");
	}
	ps->size--;
}

接下来我们看头插

void SeqListPushFront(SL* ps, SLDateType x)
{
	// 考虑扩容问题
	if ((ps->size) == (ps->capacity))
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		ps->capacity = newcapacity;

		SLDateType* tmp = (SLDateType*)realloc(ps->a, newcapacity * sizeof(SLDateType));

		if (tmp == NULL)
		{
			perror("pushback realloc");
		}

		ps->a = tmp;
	}

	// 头插
	int end = ps->size - 1;
	while (end>=0)
	{
		ps->a[end + 1] = ps->a[end];
	}

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

头删

void SeqListPopFront(SL* ps)
{
	int bejin = 0;
	while (bejin<ps->size-1)
	{
		ps->a[bejin] = ps->a[bejin + 1];
		bejin++;
	}
	ps->size--;
}

 查找

int SeqListFind(SL* ps,int x)
{
	int i;
	for ( i = 0; i < ps->size; i++)
	{
		if (ps->a[i]==x)
		{
			return i;
		}
	}
	if (i==ps->size)
	{
		printf("不存在这个数");
	}
	return -1;
}

在pos位置处插入数字

void SeqListPushPos(SL* ps, int x, int y)
{
	if ((ps->size) == (ps->capacity))
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		ps->capacity = newcapacity;
		SLDateType* tmp = (SLDateType*)realloc(ps->a, newcapacity * sizeof(SLDateType));
		if (tmp == NULL)
		{
			perror("pushback realloc");
		}
		ps->a = tmp;
	}
	// 和头插差不多 
	// 只不过头插的起始位置有点变化了
	int i;
	for (i = ps->size - 1; i >= x; i--)
	{
		(ps->a[i + 1]) = (ps->a[i]);
	}

	ps->a[x] = y;
	ps->size++;
}

在pos处删除数字

void SeqListPopPos(SL* ps, int x)
{
	assert(ps->size != 0);
	int i;
	for ( i =x; i <ps->size-1 ; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}

这里我们基本实现了顺序表的所有接口函数

三. 代码

头文件

#pragma once
#define N 100
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDateType;

typedef struct SeqList
{
	SLDateType* a; 
	int size; 
	int capacity;
}SL;


void SeqListInit(SL* ps);
void SeqListDestory(SL* ps);
void SeqListPushBack(SL* ps, SLDateType x);
void SeqListPopBack(SL* ps);
void SeqListPushFront(SL* ps, SLDateType x);
void SeqListPopFront(SL* ps);
void SeqListPrint(SL* ps);

主文件

#include"SeqList.h"

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


void SeqListInit(SL* ps)
{
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

void SeqListDestory(SL* ps)
{
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}


void SeqListCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2*ps->capacity ;
		SLDataType* tmp = (SLDataType*)realloc(ps->a, newcapacity*sizeof(SLDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
}

void SeqListPushBack(SL* ps, int x)
{
	/*SeqListCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;*/

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

}

void SeqListPopBack(SL* ps)
{
	/*if (ps->size == 0)
		return;*/

	/*assert(ps->size > 0);
	ps->size--;*/


	SeqListErase(ps, ps->size - 1);
}

void SeqListPushFront(SL* ps, int x)
{
	/*SeqListCheckCapacity(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(SL* ps)
{
	assert(ps->size > 0);

	/*int cur = 1;
	for (cur = 1; cur < ps->size; cur++)
	{
		ps->a[cur - 1] = ps->a[cur];
	}

	ps->size--;*/

	SeqListErase(ps, 0);
}

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

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

	SeqListCheckCapacity(ps);

	int end = ps->size-1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

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

	int cur = pos + 1;
	while (cur < ps->size)
	{
		ps->a[cur - 1] = ps->a[cur];
		cur++;
	}
	ps->size--;
}

=eqwe11
关注
  • 7
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
【数据结构初阶】顺序表
m0_60624580的博客
10-25 2251
前言前言线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表的数据在存储的时候是成一条线性相互紧邻存放的。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，是连续的一条直线。但是在物理结构上（内存）并不一定是连续的。线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是在物理上是线性连续的，链表是不连续的。
数据结构--顺序表
liuyq78的博客
03-08 341
2.2.3 顺序表 1、从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。 #include<stdio.h> #include<stdlib.h> #define MaxSize 50 typedef int ElemType; typedef struct SqList{ // ...
数据结构初阶--顺序表
weixin_36194037的博客
07-13 809
数据结构初阶--顺序表
数据结构初阶--顺序表和链表
weixin_67916525的博客
02-19 417
顺序表本质上就是数组。但是在此之上，顺序表要求存储的数据必须是连续紧挨着的，不能跳跃。用一段物理地址连续的存储单元依次存储数据元素的线性结构。线性表在逻辑上是线性结构，也就说是连续的一条直线。顺序表的物理结构和逻辑结构是一致的。链表是用指针把一块一块内存链接起来。
数据结构初阶--单链表
weixin_36194037的博客
07-20 676
数据结构初阶--单链表
数据结构初阶数据结构初阶
02-12
初学者在学习数据结构时，通常会遇到一系列基础概念和重要类型，这些都会在"数据结构初阶"的学习中逐步揭示。 首先，我们要理解数据结构的基本概念。数据结构是存储和组织数据的一种方式，它不仅考虑了数据的存储，...
C语言初阶-(单向链表)
03-08
适用于数据结构初学者使用 线性表的单链表存储结构，整个链表的存取必须从头指针开始进行，头指针指示链表中第一个结点 (第一个数据元素的存储映像，也称首元结点)的存储位置。同时，由于最后一个数据元素没有 直接...
C语言实现数据结构算法初阶算法
06-15
1. **顺序表**：顺序表是一种基本的数据结构，它的元素在内存中是连续存储的。C语言中，我们可以使用数组来实现顺序表。在实际应用中，插入和删除操作可能涉及大量的元素移动，效率较低，但在特定场景如全量数据处理...
【数据结构】—— 树和二叉树
mist的博客
08-26 1229
树和二叉树、堆（顺序结构）、二叉树链式结构
数据结构：用栈实现队列（232）LeetCode
2303_81073778的博客
08-26 620
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1469
数据结构-时间、空间复杂度-详解
浅谈【数据结构】树与二叉树之哈夫曼树
weixin_67526434的博客
08-26 843
浅谈【数据结构】树与二叉树之哈夫曼树
【数据结构】-----哈希
最新发布
m0_73470633的博客
08-29 573
一文看懂哈希结构！
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1119
KMP算法：理解next[]表
集合及数据结构第十二节（下）————哈希表、字符串常量池和练习题
2301_79418684的博客
08-26 812
哈希表、字符串常量池和练习题 1. 哈希表的概念 2. 冲突-概念 3. 冲突-避免 4. 冲突-解决 5. 冲突严重时的解决办法 6. 冲突严重时的解决办法的实现 7. 性能分析 8. 和 java 类集的关系 9. Hashmap的使用案例 10. 模拟实现HashMap（k-v模型） 11. 创建对象的思考 12. 字符串常量池(StringTable) 13. 再谈String对象创建 14. 练习
【JAVA】后端开发中的数据结构：基础知识与应用场景
一个不断前行的程序者
08-25 1047
*数据结构是后端开发中的基础和核心。**通过了解数据结构的基本概念、常见类型以及在日常开发中的应用场景，我们可以更好地运用数据结构来提高程序的性能和可维护性。在后端开发中，掌握数据结构对于提升个人技能和职业发展具有重要意义。在实际工作中，我们应该根据具体需求和场景选择合适的数据结构，以实现高效、稳定的系统设计。
浅谈【数据结构】树与二叉树之平衡二叉树
weixin_67526434的博客
08-26 298
浅谈【数据结构】树与二叉树之平衡二叉树
【Java & 数据结构】二叉搜索树 & TreeMap 和 TreeSet 介绍
qq_42150700的博客
08-29 446
很明显, 对于二叉搜索树来说, 如果它树的分布是对半分布的, 如下图左侧的二叉树所示. 那么此时在查找过程中每经过一个节点都会排除一半的元素, 类似于二分查找, 因此理想情况下查找的时间复杂度是 O(logN). 但是如果是最坏情况, 二叉搜索树会是一棵单叉树, 如右图所示, 那么此时每一次都只能排除一个节点, 此时查找的时间复杂度就是 O(N) 了。
严重性 代码 说明 项目 文件 行 禁止显示状态 警告 C6386 写入 "popk" 时缓冲区溢出。 heap D:\VS2022\code\data-structure\heap\heap\源.c 64
07-27
- *2* [第九章：C语言数据结构与算法初阶之堆](https://blog.csdn.net/yanyongfu523/article/details/129582526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值