数据结构与算法-线性表

已于 2022-10-02 22:17:19 修改
阅读量514 收藏
点赞数 1
分类专栏： 数据结构/算法 文章标签： 数据结构 链表
于 2022-10-01 15:12:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ProgrammersFighting/article/details/127118644
版权

数据结构与算法【C语言】

一、线性表-动态扩容数组

  优点：可按数据元素的序号随机存储，也即可按照索引快速查找某元素。
  缺点：插入和删除操作耗时。
  动态扩容原理：
     1) 若arr->size >= arr->capacity, 则开辟比capacity更大的空间；
     2) 将原空间中的元素拷贝至新的空间；
     3) 释放旧空间后，链表中的数据指针指向新开辟的空间。

1.1 仅存放整型元素的动态数组

  实现功能：
     1) 初始化动态数组-DynamicArray* Init_DynamicArray();
     2) 向动态数组中插入整型元素-void InsertValue_DynamicArray(DynamicArray arr, int data);
     3) 删除指定位置的元素/删除特定值的元素- void RemoveValueByValue_DynamicArray(DynamicArray arr, int pos);/void RemoveValueByValue_DynamicArray(DynamicArray* arr, int data);
     4) 返回动态数组的元素个数和容量 int Size_DynamicArray(DynamicArray* arr);/int Capacity_DynamicArray(DynamicArray* arr);
     5) 释放动态数组- void FreeSpace_DynamicArray(DynamicArray* arr);

   1.1.1 存放整型元素的动态数组存储结构

  仅存放整型元素的动态数组存储结构如下图所示，用链表维护动态数组的相关属性，如动态数组中的元素个数(DynamicArray.size)和动态数组的容量(DynamicArray.capacity)。
在这里插入图片描述

   1.1.2 代码
// 头文件DynamicArray.h
#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H
#include<stdlib.h>
#include<stdio.h>

// 用链表维护动态扩容数组的相关参数
typedef struct DYNAMICARRAY {
	// 用指针数组存放数据的地址
	int* addr;
	// 元素的个数
	int size;
	// 动态数组的容量
	int capacity;
}DynamicArray;

// 动态数据组初始化 
DynamicArray* Init_DynamicArray();

// 插入数据
void InsertValue_DynamicArray(DynamicArray *arr, int data);

// 删除指定位置的数据
void RemoveValueByPos_DynamicArray(DynamicArray* arr, int pos);

// 根据值删除元素
void RemoveValueByValue_DynamicArray(DynamicArray* arr, int data);

// 返回数组的容量和尺寸
int Size_DynamicArray(DynamicArray* arr);

// 返回数组的容量
int Capacity_DynamicArray(DynamicArray* arr);

// 打印数组
void Print_DynamicArray(DynamicArray* arr);

// 清空数组
void Clear_DynamicArray(DynamicArray* arr);

// 释放数组内存
void FreeSpace_DynamicArray(DynamicArray* arr);

#endif // !DYNAMICARRAY_H

// DynamicArray.c
// DynamicArray.c为头文件DynamicArray.h中所申明函数的实现。
#include"DynamicArray.h"
// 动态数据组初始化 
DynamicArray* Init_DynamicArray() {
	// 初始化动态数组
	DynamicArray* arr = (DynamicArray*)malloc(sizeof(DynamicArray));
	if (arr == NULL) {
		printf("内存分配失败!");
		return NULL;
	}
	else {
		arr->size = 0;
		arr->capacity = 10;
		arr->addr = (int*)malloc(sizeof(int) * arr->capacity);
		return arr;
	}
}

// 插入数据
void InsertValue_DynamicArray(DynamicArray* arr, int data) {
	// 判断边界情况
	if (arr == NULL) {
		printf("数组arr为空，请初始化动态数组: arr\n");
		return;
	}
	// 如果当前元素个数超出动态数组的容量
	if (arr->size >= arr->capacity) {
		// 更新动态数组的容量
		arr->capacity = arr->capacity * 2;
		// 开辟新空间
		int* temp = (int*)malloc(sizeof(int) * arr->capacity);
		// 将旧空间的元素拷贝至新开辟的空间中
		for (int i = 0; i < arr->size; i++) {
			temp[i] = arr->addr[i];
		}
		// 销毁旧空间
		free(arr->addr);
		arr->addr = temp;
	}
	// 插入新的元素
	arr->addr[arr->size] = data;
	arr->size++;
}

// 删除指定位置的数据
void RemoveValueByPos_DynamicArray(DynamicArray* arr, int pos) {
	// 判断数组arr，和位置pos是否合法
	if (arr == NULL || pos >= arr->size || pos < 0) {
		// 传入参数有误
		printf("传入参数有误,请检查参数\n");
		return;
	}
	// 将pos位置后的元素往前移动
	for (int i = pos; i < arr->size - 1; i++) {
		arr->addr[i] = arr->addr[i + 1];
	}
	// arr->size--
	arr->size--;
}

// 根据传入的值删除数据
void RemoveValueByValue_DynamicArray(DynamicArray* arr, int data) {
	// 判断数组arr，和位置pos是否合法
	if (arr == NULL) {
		// 传入参数有误
		printf("传入参数有误,请检查参数\n");
		return;
	}

	// 找到arr中第一个元素为data的位置
	for (int i = 0; i < arr->size; i++) {
		if (arr->addr[i] == data) {
			if (i == arr->size - 1) {
				arr->size--;
				return;
			}
			else {
				for (int j = i; j < arr->size - 1; j++) {
					arr->addr[j] = arr->addr[j + 1];
				}
				arr->size--;
				return;
			}
		}
	}
	// arr->size--
}

// 返回数组的容量和尺寸
int Size_DynamicArray(DynamicArray* arr) {
	// 判断边界情况
	if (arr == NULL) {
		printf("数组为空，请初始化数组\n");
		return -1;
	}
	return arr->size;
}

// 返回数组的容量
int Capacity_DynamicArray(DynamicArray* arr) {
	// 判断边界情况
	if (arr == NULL) {
		printf("数组为空，请初始化数组\n");
		return -1;
	}
	return arr->capacity;
}

// 打印数组
void Print_DynamicArray(DynamicArray* arr) {
	if (arr == NULL) return;
	for (int i = 0; i < arr->size; i++) {
		printf("%d ", arr->addr[i]);
	}
	printf("\n");
}

// 清空数组
void Clear_DynamicArray(DynamicArray* arr) {
	if (arr == NULL) return;
	arr->size = 0;
}

// 释放数组内存
void FreeSpace_DynamicArray(DynamicArray* arr) {
	if (arr == NULL) return;
	// 由内往外释放
	if (arr->addr) free(arr->addr);
	free(arr);
}

// main.c 完成对动态数组中相关功能的测试。
#include"DynamicArray.h"
#include <time.h>

#define MAX_NUM 10

void GenRandomData(DynamicArray *arr, int len) {
	if (arr == NULL || len < 0) return;
	srand((unsigned int)time(NULL));
	for (int i = 0; i < len; i++) {
		InsertValue_DynamicArray(arr, rand() % len);
	}
}

int main() {
	// 初始化数组
	DynamicArray* arr = Init_DynamicArray();

	// 向动态数组中插入元素
	/*for (int i = 0; i < 20; i++) {
		InsertValue_DynamicArray(arr, i);
	}*/
	// 随机插入元素
	GenRandomData(arr, MAX_NUM);

	// 删除前的数组
	printf("根据位置删除前的数组：\n");
	Print_DynamicArray(arr);
	// 根据位置删除元素
	RemoveValueByPos_DynamicArray(arr, 8);
	// 删除后的数组
	printf("根据位置删除后的数组：\n");
	Print_DynamicArray(arr);

	// 根据值删除数组
	RemoveValueByValue_DynamicArray(arr, 0);
	printf("根据元素删除后的数组：\n");
	Print_DynamicArray(arr);
	printf("\n=====================\n");
	// 数组大小
	printf("数组元素个数：%d\n", Size_DynamicArray(arr));
	// 数组容量
	printf("数组容量：%d\n", Capacity_DynamicArray(arr));
	
	// 清空数组
	Clear_DynamicArray(arr);
	printf("\n清空后的动态数组：");
	// 数组大小
	printf("数组元素个数：%d\n", Size_DynamicArray(arr));
	// 数组容量
	printf("数组容量：%d\n", Capacity_DynamicArray(arr));

	// 释放空间
	FreeSpace_DynamicArray(arr);
	return 0;
}
   1.1.3 运行结果

     运行结果如下所示，
动态数组测试结果

1.2 存放任意类型数据的动态数组

   1.2.1 存放任意类型数据的动态数组存储结构

  在1.1小节上进行扩展：实现线性存储任意类型的数据的动态数组，其存储的数据结构如下图所示，ArrayNode结点的viod*data可以指向任意类型的数据。
在这里插入图片描述

   1.2.2 代码
// 头文件DynamicArray.h
#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H
#include<stdlib.h>
#include<stdio.h>


// 打印函数-由用户自己提供打印的接口，
typedef void (*PRINT)(void*);
// 比较函数
typedef int (*COMPARE)(void*, void*);

typedef struct ARRAYNODE {
	void* data;
}ArrayNode;
// 用链表维护动态扩容数组的相关参数
typedef struct DYNAMICARRAY {
	// 用指针数组存放数据的地址
	ArrayNode* arrNode;
	//void* data;
	// 元素的个数
	int size;
	// 动态数组的容量
	int capacity;
}DynamicArray;

// 动态数据组初始化 
DynamicArray* Init_DynamicArray();

// 插入数据
void InsertData_DynamicArray(DynamicArray* arr, void* data);

// 删除指定位置的数据
void RemoveValueByPos_DynamicArray(DynamicArray* arr, int pos);

// 根据值删除元素
void RemoveValueByValue_DynamicArray(DynamicArray* arr, void* data, COMPARE compare);

// 返回数组的容量和尺寸
int Size_DynamicArray(DynamicArray* arr);

// 返回数组的容量
int Capacity_DynamicArray(DynamicArray* arr);

// 打印数组
void Print_DynamicArray(DynamicArray* arr, PRINT print);

// 清空数组
void Clear_DynamicArray(DynamicArray* arr);

// 释放数组内存
void FreeSpace_DynamicArray(DynamicArray* arr);

#endif // !DYNAMICARRAY_H

// DynamicArray.c
#include"DynamicArray.h"

// 动态数据组初始化 
DynamicArray* Init_DynamicArray() {
	// 初始化动态数组
	DynamicArray* arr = (DynamicArray*)malloc(sizeof(DynamicArray));
	if (arr == NULL) {
		printf("内存分配失败!\n");
		return NULL;
	}
	else {
		arr->size = 0;
		arr->capacity = 3;
		arr->arrNode = (ArrayNode*)malloc(sizeof(ArrayNode) * arr->capacity);
		return arr;
	}
}

// 插入数据
void InsertData_DynamicArray(DynamicArray* arr, void* data) {
	// 判断边界情况
	if (arr == NULL) {
		printf("数组arr为空，请初始化动态数组: arr\n");
		return;
	}
	// 如果当前元素个数超出动态数组的容量
	if (arr->size >= arr->capacity) {
		// 更新容量
		arr->capacity = arr->capacity * 2;
		// 开辟新空间
		ArrayNode* NewArrayNode = (ArrayNode*)malloc(sizeof(ArrayNode) * arr->capacity );
		// 将旧空间的元素拷贝至新开辟的空间中
		for (int i = 0; i < arr->size; i++) {
			NewArrayNode[i].data = arr->arrNode[i].data;
		}
		// 销毁旧空间
		free(arr->arrNode);
		arr->arrNode = NewArrayNode;
	}
	// 插入新的元素
	arr->arrNode[arr->size].data = data;
	arr->size++;
}

// 删除指定位置的数据
void RemoveValueByPos_DynamicArray(DynamicArray* arr, int pos) {
	// 判断数组arr，和位置pos是否合法
	if (arr == NULL || pos >= arr->size || pos < 0) {
		// 传入参数有误
		printf("传入参数有误,请检查参数\n");
		return;
	}
	// 将pos位置后的元素往前移动
	for (int i = pos; i < arr->size - 1; i++) {
		arr->arrNode[i].data = arr->arrNode[i + 1].data;
	}
	// arr->size--
	arr->size--;
}

// 根据传入的值删除数据
void RemoveValueByValue_DynamicArray(DynamicArray* arr, void* data, COMPARE compare) {
	// 判断数组arr，和位置pos是否合法
	if (arr == NULL) {
		// 传入参数有误
		printf("传入参数有误,请检查参数\n");
		return;
	}

	// 找到arr中第一个元素为data的位置
	for (int i = 0; i < arr->size; i++) {
		if (compare(arr->arrNode[i].data, data) == 1) {
			if (i == arr->size - 1) {
				arr->size--;
				return;
			}
			else {
				for (int j = i; j < arr->size-1; j++) {
					arr->arrNode[j].data = arr->arrNode[j + 1].data;
				}
				// 元素个数减1
				arr->size--;
				return;
			}
		}
	}
}

// 返回数组的容量和尺寸
int Size_DynamicArray(DynamicArray* arr) {
	// 判断边界情况
	if (arr == NULL) {
		printf("数组为空，请初始化数组\n");
		return -1;
	}
	return arr->size;
}

// 返回数组的容量
int Capacity_DynamicArray(DynamicArray* arr) {
	// 判断边界情况
	if (arr == NULL) {
		printf("数组为空，请初始化数组\n");
		return -1;
	}
	return arr->capacity;
}

// 打印数组
void Print_DynamicArray(DynamicArray* arr, PRINT print) {
	if (arr == NULL) return;
	for (int i = 0; i < arr->size; i++) {
		print(arr->arrNode[i].data);
	}
	printf("\n");
}

// 清空数组
void Clear_DynamicArray(DynamicArray* arr) {
	if (arr == NULL) return;
	arr->size = 0;
}

// 释放数组内存
void FreeSpace_DynamicArray(DynamicArray* arr) {
	if (arr == NULL) return;
	// 由内往外释放
	if (arr->arrNode) free(arr->arrNode);
	free(arr);
}

// main.c
#include"DynamicArray.h"
#include<string.h>
#include <time.h>

#define MAX_NUM 10

typedef struct PERSON {
	char name[64];
	int age;
}Person;


// 打印函数
void myPrint(void* data) {
	Person* p = (Person*)data;
	printf("姓名：%s，年龄：%d\n", p->name, p->age);
}

// 比较函数, data1为动态数组中的元素，data2为用户传入的数据
int compare(void* data1, void* data2) {
	Person* p1 = (Person*)data1;
	Person* p2 = (Person*)data2;
	// 如果姓名和年龄均相等，则判定data1与data2相等
	if (!strcmp(p1->name, p2->name) && p1->age == p2->age) return 1;
	return -1;
}

int main() {
	// 初始化结构体
	Person p1 = { "aaa", 20 }, p2 = { "bbb", 30 }, p3 = { "ccc", 40 }, p4 = {"ddd", 50};

	// 初始化数组
	DynamicArray* arr = Init_DynamicArray();

	// 插入结构体数据
	InsertData_DynamicArray(arr, &p1);
	InsertData_DynamicArray(arr, &p2);
	InsertData_DynamicArray(arr, &p3);
	InsertData_DynamicArray(arr, &p4);

	// 删除前的数组
	printf("删除前的数组：\n");
	Print_DynamicArray(arr, myPrint);

	// 根据位置删除元素
	//RemoveValueByPos_DynamicArray(arr, 0);
	// 删除后的数组
	printf("根据位置删除后的数组：\n");
	Print_DynamicArray(arr, myPrint);

	// 根据值删除数组
	Person p5 = {"ddd", 50};
	RemoveValueByValue_DynamicArray(arr, &p5, compare);
	printf("根据元素删除后的数组：\n");
	Print_DynamicArray(arr, myPrint);


	printf("\n=====================\n");
	// 数组大小
	printf("数组元素个数：%d\n", Size_DynamicArray(arr));
	// 数组容量
	printf("数组容量：%d\n", Capacity_DynamicArray(arr));
	Clear_DynamicArray(arr);
	printf("\n清空后的动态数组：");
	// 数组大小
	printf("数组元素个数：%d\n", Size_DynamicArray(arr));
	// 数组容量
	printf("数组容量：%d\n", Capacity_DynamicArray(arr));


	// 释放空间
	FreeSpace_DynamicArray(arr);

	return 0;
}
   1.2.3 运行结果

     向动态数组中插入结构体数据，运行结果如下所示，
在这里插入图片描述

二、参考链接

   1、数据结构与算法知识点总结
   2、C++教程

Salute=
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
头歌C++数据结构与算法 - 线性表
03-04
头歌C++数据结构与算法 - 线性表
Java数据结构与算法-线性表
ly_better的博客
11-02 605
1.1线性表的基本概念 线性表是由n个数据元素所构成的有限序列. 对于同一个线性表，其每一个数据元素的值虽然不同，但必须具有相同的数据类型；同时，数据元素之间具有一种线性
头歌-数据结构与算法 - 线性表
mlws1900的博客
10-06 3574
【代码】头歌-数据结构与算法 - 线性表。
Java数据结构与算法-线性表（详细实现）
qq_41649001的博客
07-25 3091
线性表（Linear List） 2.1 什么是线性表 零个或多个数据元素的有限序列。 非空线性表的逻辑结构特征 有且仅有一个开始结点，无直接前趋，有且只有一个直接后继 有且仅有一个结束结点，有且只有一个直接前趋，无直接前驱。 内部结点都有且只有一个直接前趋和一个直接后继 对于同一线性表，数据类型一直，数据元素长度一致。 2.2 线性表基本运算 基本运算包括 initList 初始化操作，建立一个空的线性表 listEmpty 若线性表为空，返回true，否则返回false
数据结构与算法 - 线性表
m0_46478866的博客
03-27 3802
数据结构与算法 - 线性表前言第1关：实现一个顺序存储的线性表第2关：实现一个链接存储的线性表总结 前言 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用顺序存储，也可以采用链接存储。本实训项目的主要目标是学习和掌握基于 C 语言实现线性表，主要内容包括基于顺序存储和链接存储的方式来实现线性表。 提示：以下是本篇文章正文内容，下面案例可供参考 第1关：实现一个顺序存储的线性表 本关任务：实现 step1/Seqlist
Educoder题目：数据结构与算法 - 线性表答案解析.md
10-18
Educoder题目：数据结构与算法 - 线性表答案解析.md
数据结构与算法-线性表 定义线性表节点的结构.pdf
04-18
数据结构与算法-线性表 定义线性表节点的结构.pdf
数据结构与算法-线性表的设计与实现 定义线性表节点的结构.pdf
04-18
数据结构与算法-线性表的设计与实现 定义线性表节点的结构.pdf
数据结构与算法－线性表顺序存储及其相关算法 定义线性表节点的结构.pdf
04-18
数据结构与算法－线性表顺序存储及其相关算法 定义线性表节点的结构.pdf
【数据结构】一文了解二叉树的顺序结构（堆）
tidal_wave的博客
05-18 724
普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。以上就是今天要讲的内容，本文仅仅简单介绍了堆的使用，而堆提供了大量能使我们快速便捷地处理数据的思路。以后博主会继续介绍二叉树的其他知识，期待你的阅读。
数据结构——二叉树知识点详解！
hu_ju_hong的博客
05-15 641
数据结构二叉树概念超详细讲解！同时也是学习数据结构——堆的必修课！
Pandas数据结构
eqwaak0的博客
05-15 958
类似表格中的一个列（column），类似于一维数组，可以保存任何数据类型。DataFrame是 Pandas 中的另一个核心数据结构，用于表示二维表格型数据。是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。
【数据结构1.0】归并排序
X__cheng的博客
05-18 311
本博客以排升序为例介绍归并排序！我们先看一个问题：有两组均为升序的数组要合并到一组数组当中，要求合并后的数组也是升序的，怎么办？办法：从头开始遍历两组数组，找“小”尾插到合并数组当中。举例如图：这其实是归并的思想！归并排序的基本思想：归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有 序，再使子序列段间有序。
数据结构------二叉树经典习题2
jj666mhhh的博客
05-18 468
-二叉树经典习题
【数据结构】快速排序（详解）
最新发布
lzh20040919的博客
05-21 703
在待排序的序列中，选择一个元素作为基准元素（key）。这个元素可以是序列的第一个元素、最后一个元素或者任意一个元素，甚至是随机选取的一个元素。：从序列的一端开始（可以是左端或右端），将遇到的第一个比基准元素小（或大）的元素填入坑中，并形成一个新的坑。在非递归版本中，我们使用栈（或队列）来保存待排序的子数组的起始和结束索引，而不是直接递归调用；：一个记录序列的开始的下标（left），另一个记录序列的末尾的下标（right）。：此时，基准值左边的所有元素都比基准值小，基准值右边的所有元素都比基准值大。
【数据结构】神奇的二叉树
flmz_Kk的博客
05-18 684
详细介绍数据结构中二叉树的概念，遍历等等
【数据结构】堆（超详细）
qq_74897518的博客
05-14 986
堆
【数据结构】数据结构大汇总 {数据结构的分类总结：定义和特性、实现方式、操作与复杂度、适用场景、相关算法、应用实例}
芥末虾的博客
05-15 864
【数据结构】数据结构大汇总 {数据结构的分类总结：定义和特性、实现方式、操作与复杂度、适用场景、相关算法、应用实例}

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值