C语言-数据结构-顺序表

会编程的果子君2024-02-28 17:32

🌈个人主页: 会编辑的果子君

💫个人格言:"成为自己未来的主人~"

目录

数据结构相关概念

顺序表

顺序表的概念和结构

线性表

顺序表分类

顺序表和数组的区别

顺序表分类

静态顺序表

动态顺序表

头插和尾插

尾插

数据结构相关概念

数据结构是由"数据"和"结构"两词组合而来。

什么是数据？常见的数值1,2,3,4.....，教务系统里保存的用户信息，（姓名，性别，年龄，学历等），网页里肉眼可以看到的信息（文字，图片，视频等等），这些都是数据。

什么是结构？

当我们想要使用大量使用同一类型的数据时，通过手动定义大量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将大量的数据组织在一起，结构也可以理解为组织数据方式。

概念：数据结构是计算机存储，组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的元素的集合，数据结构反映数据的内部构成，即数据由哪部分构成，以什么方式构成，以及数据元素之间呈现的结构。

总结：

1）能够存储数据结构（如顺序表，链表等结构）

2）存储的数据能够方便查找

数据结构需要用到结构体，指针（一级指针，二级指针，指针传参），结构体指针，动态内存管理

顺序表

顺序表的概念和结构

线性表

线性表是N个具有相同特性的数据元素的有限序列，线性表是一种是实际中极其有用的数据结构，常用的线性表：顺序表，链表，栈，队列，字符串.....

线性表在逻辑上是线性结构，也就是说是连续的一条直线，但是在物理结构上并不一定是连续的

线性表在物理上存储时，通常是以数组和链式结构的形式存储。

顺序表：逻辑结构是线性的，物理结构是连续的

顺序表分类

顺序表和数组的区别

顺序表的底层结构是数组，对数组的封装，实现了常用的增删改查等接口

顺序表分类

静态顺序表

使用定长数组存储元素

cpp 复制代码 
typedef int SLDataType;
#define N 10
struct SeqList {
	SLDataType a[N];//定长数组
	int size; //有效数组个数

}SL;

静态顺序表的缺陷：空间给少了不够用，给多了造成空间浪费

在上面的代码中，还有一个优点在于 int 可以立即替换而不影响下面的代码执行

动态顺序表

cpp 复制代码 
//动态顺序表-按需申请
typedef int SLDataType;
typedef struct SeqList {
	SLDataType* arr;//存储数据的底层逻辑
	int capacity;   //记录顺序表的空间
	int size;       //记录顺序表的当前的有效存储
}SL;

动态顺序表，可增容

静态顺序表，给定的数组长度，若不够，会导致后续的数据保存失败，数据丢失是非常严重的技术事故

给多了，会导致空间的大量浪费

cpp 复制代码 
//初始化和销毁
void SLInit(SL* ps) {
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

//检查
void SLChectCapacity(SL* ps) {
	if (ps->size = ps->capacity) {
		int newCapacity = ps->capacity = 0 ? 4 : 2 * ps->capacity;
		SLDataType tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		//扩容成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}
cpp 复制代码 
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps);//保持接口一致性

头插和尾插

尾插

空间足够，直接插入

空间不够，扩容

扩容的原则：

一次扩充一个空间，插入一个元素还不会造成看空间浪费，程序执行效率低

一次扩容固定大小的空间（10,100）

小了造成频繁扩容

大了造成空间浪费

成倍数的增加（1.5倍，2倍）

数据插入的越多，扩容的大小越来越大

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS
#include"code.2.26.h"
//初始化和销毁
void SLInit(SL* ps) {
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

//检查
void SLCheckCapacity(SL* ps) {
	if (ps->size == ps->capacity) {
		int newCapacity = ps->capacity = 0 ? 4 : 2 * ps->capacity;
		SLDataType tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		//扩容成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}
//顺序表的头插/尾插
void SLPushBack(SL* ps, SLDataType x) {
	//断言，粗暴的解决办法
	//assert(ps!=NULL);
	assert(ps);
	//if判断--温柔的解决办法
	/*if (ps == NULL) {
		return;
	}*/
	//空间不够，扩容
	SLCheckCapacity(ps);
	//空间足够，直接插入
	ps->arr[ps->size++] = x;
}
void SLDestroy(SL* ps) {

}
void SLPrint(SL* ps) {
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}
cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS
#include"code.2.26.h"
void slTest01() {
	SL s1;
	SLInit(&s1);
	//测试尾插
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);
	SLPrint(&s1); //1 2 3 4
}

int main() {
	slTest01();

	return 0;
}
cpp 复制代码 
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//静态顺序表

//typedef int SLDataType;
//#define N 10
//struct SeqList {
//	SLDataType a[N];//定长数组
//	int size; //有效数组个数
//
//}SL;

//动态顺序表-按需申请
typedef int SLDataType;
typedef struct SeqList {
	SLDataType* arr;//存储数据的底层逻辑
	int capacity;   //记录顺序表的空间
	int size;       //记录顺序表的当前的有效存储
}SL;

//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps);//保持接口一致性
//顺序表的头部/尾部插入
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);

//打印顺序表
void SLPrint(SL* ps);
cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS
#include"code.2.26.h"
void slTest01() {
	SL s1;
	SLInit(&s1);
	//测试尾插
	SLPushBack(&s1, 1);
	SLPushBack(&s1, 2);
	SLPushBack(&s1, 3);
	SLPushBack(&s1, 4);

	SLErase(&s1, 1);
	SLPrint(&s1); //1 2 3 4

}

int main() {
	slTest01();

	return 0;
}
cpp 复制代码 
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//静态顺序表

//typedef int SLDataType;
//#define N 10
//struct SeqList {
//	SLDataType a[N];//定长数组
//	int size; //有效数组个数
//
//}SL;

//动态顺序表-按需申请
typedef int SLDataType;
typedef struct SeqList {
	SLDataType* arr;//存储数据的底层逻辑
	int capacity;   //记录顺序表的空间
	int size;       //记录顺序表的当前的有效存储
}SL;

//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps);//保持接口一致性
//顺序表的头部/尾部插入
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);
//顺序表的头部/尾部删除
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);
//指定位置之前插入数据
//删除指定位置数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
//打印顺序表
void SLPrint(SL* ps);
cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS
#include"code.2.26.h"
//初始化和销毁
void SLInit(SL* ps) {
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

//检查
void SLCheckCapacity(SL* ps) {
	if (ps->size == ps->capacity) {
		int newCapacity = ps->capacity = 0 ? 4 : 2 * ps->capacity;
		SLDataType tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		//扩容成功
		ps->arr = tmp;
		ps->capacity = newCapacity;
	}
}
//顺序表的头插/尾插
void SLPushBack(SL* ps, SLDataType x) {
	//断言，粗暴的解决办法
	//assert(ps!=NULL);
	assert(ps);
	//if判断--温柔的解决办法
	/*if (ps == NULL) {
		return;
	}*/
	//空间不够，扩容
	SLCheckCapacity(ps);
	//空间足够，直接插入
	ps->arr[ps->size++] = x;
}
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	//判断是否扩容
	SLCheckCapacity(ps);
	//旧数据往后挪动一位
	for (int i = ps->size; i > 0; i++)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}
//顺序表的头部/尾部删除
void SLPopBack(SL* ps) {
	assert(ps);
	assert(ps->size);

	//顺序表不为空
	ps->size--;
}
void SLPopFront(SL* ps) {
	assert(ps);
	assert(ps->size);
	
	//不为空执行挪动操作
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
//指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x) {
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);
	//pos及之后的数据往后挪动一位，pos空出来
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}
//删除指定位置数据
void SLErase(SL* ps, int pos) {
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	//pos以后的数据往前挪动一位
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}
void SLDestroy(SL* ps) {

}
void SLPrint(SL* ps) {
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}
相关推荐
圈圈编码41 分钟前
LeetCode Hot100刷题——合并两个有序链表
java·数据结构·算法·leetcode·链表
jingfeng5142 小时前
详解快排的四种方式
数据结构·算法·排序算法
蒙奇D索大4 小时前
【数据结构】图论最短路径算法深度解析：从BFS基础到全算法综述
数据结构·算法·图论·广度优先·图搜索算法
AL流云。8 小时前
【优选算法】分治
数据结构·算法·leetcode·排序算法
行驶9 小时前
数据结构 - 栈与队列
数据结构
haoly19899 小时前
数据结构篇--分离链表vs线性探测
数据结构
小贾要学习9 小时前
【数据结构】AVL树的实现
数据结构
andyweike9 小时前
数据结构-文件
数据结构
andyweike9 小时前
数据结构-线性表
数据结构
思捻如枫18 小时前
C++数据结构和算法代码模板总结——算法部分
数据结构·c++
热门推荐
01【图像处理与机器视觉】XJTU期末考点02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03KGG转MP3工具|非KGM文件|解密音频04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！07零代码入门 | Coze——让大模型接入自己的数据库08海康Visionmaster-常见问题排查方法-启动阶段09DeepSeek各版本说明与优缺点分析10R-tree详解