Day24.C提高（数据结构01）

最新推荐文章于 2024-07-24 10:46:51 发布
最新推荐文章于 2024-07-24 10:46:51 发布
阅读量83 收藏
点赞数
分类专栏： 学习笔记 文章标签： c语言 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xu_06161014/article/details/116198123
版权

Day24.C提高（数据结构01）

001.动态数组简单实现

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//1.先把所需要的数据信息结构定义下来
struct DynamicArray
{
	//数组存储元素的空间的首地址
	void** addr;
	//存储数据的内存中最大能够容纳多少元素
	int capacity;//容量
	//当前存储数据的内存中有多少个元素
	int size;
};

//初始化数组
int Init_DynamicArray(int capacity, struct DynamicArray** arr)
{
	if (capacity == NULL)
	{
		return -1;
	}
	if (arr == NULL)
	{
		return -1;
	}
	struct DynamicArray* buf = malloc(sizeof(struct DynamicArray));
	buf->capacity = capacity;
	buf->addr = malloc(sizeof(void*) * buf->capacity);
	buf->size = 0;
	*arr = buf;
}
//插入元素
void Insert_DynamicArray(struct DynamicArray* arr, int pos, void* data)
{
	if (NULL == arr)
	{
		return;
	}
	if (NULL == data)
	{
		return;
	}
	if (pos > arr->size || pos < 0)
	{
		pos = arr->size;
	}
	//判断空间是否足够
	if (arr->size >= arr->capacity)
	{
		//1.申请一块更大的内存空间
		int newcapacity = arr->capacity * 2;
		void** newspace = malloc(sizeof(void*) * newcapacity);
		//2.将原来空间的数据拷贝到新空间
		memcpy(newspace, arr->addr, sizeof(void*) * arr->capacity);
		//3.释放原来的内存空间
		if (NULL != arr->addr)
		{
			free(arr->addr);
			arr->addr = NULL;
		}
		//4.更新addr指向，以及动态数组的容量
		arr->addr = newspace;
		arr->capacity = newcapacity;
	}
	//移动元素，给pos位置空出位置来
	for (int i = arr->size - 1; i >= pos; --i)
	{
		arr->addr[i + 1] = arr->addr[i];
	}
	//将新元素插入到pos位置
	arr->addr[pos] = data;
	arr->size++;

}
//遍历
void Foreach_DynamicArray(struct DynamicArray* arr, void(*_callback)(void*))
{
	if (NULL == arr)
	{
		return;
	}
	if (NULL == _callback)
	{
		return;
	}
	for (int i = 0; i < arr->size; ++i)
	{
		_callback(arr->addr[i]);
	}

}

//按位置删除
void RemoveByPos_DynamicArray(struct DynamicArray* arr, int pos)
{
	if (NULL == arr)
	{
		return;
	}
	if (pos<0 || pos>arr->size - 1)
	{
		return;
	}
	for (int i = pos; i < arr->size - 1; ++i)
	{
		arr->addr[i] = arr->addr[i + 1];
	}
	arr->size--;
}

//按值删除
void RemoveByValue_DynamicArray(struct DynamicArray* arr, void* data,int(*MYCOMPARE)(void*,void*))
{
	if (NULL == arr)
	{
		return;
	}
	if (NULL == data)
	{
		return;
	}
	if (NULL == MYCOMPARE)
	{
		return;
	}

	for (int i = 0; i < arr->size; ++i)
	{
		if (MYCOMPARE(arr->addr[i], data))
		{
			//找到了（调用按位置删除）
			RemoveByPos_DynamicArray(arr, i);
			break;
		}
	}

}

//销毁数组
void Destroy_DynamicArray(struct DynamicArray* arr)
{
	if (NULL == arr)
	{
		return;
	}
	if (arr->addr != NULL)
	{
		free(arr->addr);
		arr->addr = NULL;
	}
	free(arr);
	arr = NULL;
}

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

void myPrintf(void* data)
{
	struct Person* person = (struct Person*)data;
	printf("Name:%s Age:%d\n", person->name, person->age);
}

void myComepare_1(void* d1, void* d2)
{
	struct Person* p1 = (struct Person*)d1;
	struct Person* p2 = (struct Person*)d2;

	return strcmp(p1->name, p2->name) == 0 && p1->age == p2->age;
}

void test101()
{
	//创建动态数组
	struct DynamicArray* da;
	Init_DynamicArray(5, &da);
	struct Person p1 = { "aaa",10 };
	struct Person p2 = { "bbb",20 };
	struct Person p3 = { "ccc",30 };
	struct Person p4 = { "ddd",40 };
	struct Person p5 = { "eee",50 };
	struct Person p6 = { "fff",60 };

	//动态数组添加元素
	Insert_DynamicArray(da, 0, &p1);
	Insert_DynamicArray(da, 0, &p2);
	Insert_DynamicArray(da, 0, &p3);
	Insert_DynamicArray(da, 1, &p4);
	Insert_DynamicArray(da, 1, &p5);//3 5 4 2 1
	printf("容量：%d\n", da->capacity);
	Insert_DynamicArray(da, 100, &p6);//3 5 4 2 1 6
	printf("容量：%d\n", da->capacity);

	//遍历打印
	Foreach_DynamicArray(da, myPrintf);

	//按位置删除
	RemoveByPos_DynamicArray(da, 2);//3 5 2 1 6
	//遍历打印
	printf("----------------\n");
	Foreach_DynamicArray(da, myPrintf);

	//按值删除
	struct Person pDel = { "aaa",10 };
	RemoveByValue_DynamicArray(da, &pDel, myComepare_1);

	//遍历打印
	printf("----------------\n");
	Foreach_DynamicArray(da, myPrintf);

	//销毁
	Destroy_DynamicArray(da);
}

int main(void)
{
	test101();

	system("pause");
	return EXIT_SUCCESS;
}

002.单向链表（版本一）

LinkList.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

#ifdef __cplusplus
extern "C" {
#endif

	//链表结点数据类型
	struct LinkNode
	{
		void* data;
		struct LinkNode* next;
	};

	//链表数据类型
	struct LList
	{
		struct LinkNode header;
		int size;
	};

	//函数指针变量
	typedef void(*FOREACH)(void*);
	typedef int(*COMPARE)(void*, void*);

	typedef void* LinkList;
	//初始化链表
	LinkList Init_LinkList();
	//插入结点（按位置插入）
	void insert_LinkList(LinkList list, int pos, void* data);
	//遍历链表
	void Foreach_LinkList(LinkList list, FOREACH myforeach);
	//按位置删除
	void RemoveByPos_LinkList(LinkList list, int pos);
	//按值删除
	void RemoveByVal_LinkList(LinkList list, void* data, COMPARE compare);
	//清空链表
	void Clear_LinkList(LinkList list);
	//大小
	int Size_LinkList(LinkList list);
	//销毁链表
	void Destroy_LinkList(LinkList list);


#ifdef __cplusplus
}
#endif

LinkList.c

#include"LinkList.h"

//初始化链表（给链表分配内存）
LinkList Init_LinkList()
{
	struct LList* list = malloc(sizeof(struct LList));
	if (NULL == list)
	{
		return NULL;
	}
	list->header.data = NULL;
	list->header.next = NULL;
	list->size = 0;

	return list;
}
//插入结点（按位置插入）
void insert_LinkList(LinkList list, int pos, void* data) 
{
	if (NULL == list)
	{
		return;
	}
	if (NULL == data)
	{
		return;
	}
	struct LList* mylist = (struct LList*)list;
	if (pos < 0 || pos > mylist->size)
	{
		pos = mylist->size;
	}

	//查找插入位置
	struct LinkNode* pCurrent = &(mylist->header);
	for (int i = 0; i < pos; ++i)
	{
		pCurrent = pCurrent->next;
	}
	//创建新节点
	struct LinkNode* newnode = malloc(sizeof(struct LinkNode));
	newnode->data = data;
	newnode->next = NULL;

	//新节点插入到链表中
	newnode->next = pCurrent->next;
	pCurrent->next = newnode;

	mylist->size++;
}
//遍历链表
void Foreach_LinkList(LinkList list, FOREACH myforeach)/*回调函数*/
{
	if (NULL == list)
	{
		return;
	}
	if (NULL == myforeach)
	{
		return;
	}

	struct LList* mylist = (struct LList*)list;
	struct LinkNode* pCurrent = mylist->header.next;

	while (pCurrent != NULL)
	{
		myforeach(pCurrent->data);
		pCurrent = pCurrent->next;
	}
}

//按位置删除
void RemoveByPos_LinkList(LinkList list, int pos)
{
	if (NULL == list)
	{
		return;
	}
	
	struct LList* mylist = (struct LList*)list;
	if (pos < 0 || pos > mylist->size - 1)
	{
		return;
	}

	//查找插入位置
	struct LinkNode* pCurrent = &(mylist->header);
	for (int i = 0; i < pos; ++i)
	{
		pCurrent = pCurrent->next;
	}
	//先保存待删除结点
	struct LinkNode* pDel = pCurrent->next;
	//重新建立待删除结点的前驱和后继节点关系
	pCurrent->next = pDel->next;
	//释放删除结点内存
	free(pDel);
	pDel = NULL;

	mylist->size--;
}
//按值删除
void RemoveByVal_LinkList(LinkList list, void* data, COMPARE compare)
{
	if (NULL == list)
	{
		return;
	}
	if (NULL == data)
	{
		return;
	}
	if (NULL == compare)
	{
		return;
	}
	struct LList* mylist = (struct LList*)list;
	//辅助指针变量
	struct LinkNode* pPrev = &(mylist->header);
	struct LinkNode* pCurrent = pPrev->next;

	while (pCurrent != NULL)
	{
		if (compare(pCurrent->data, data))
		{
			//找到待删除结点（重新建立待删除结点的前驱和后继节点关系）
			pPrev->next = pCurrent->next;
			//释放删除结点内存
			free(pCurrent);
			pCurrent = NULL;
			mylist->size--;
			break;
		}
		pPrev = pCurrent;
		pCurrent = pCurrent->next;
	}

}

//清空链表
void Clear_LinkList(LinkList list)
{
	if (NULL == list)
	{
		return;
	}
	struct LList* mylist = (struct LList*)list;
	//辅助指针变量
	struct LinkNode* pCurrent = mylist->header.next;
	while (pCurrent != NULL)
	{
		//先缓存下一个节点的地址
		struct LinkList* pNext = pCurrent->next;
		//释放当前节点
		free(pCurrent);

		pCurrent = pNext;
	}
	mylist->header.next = NULL;
	mylist->size = 0;
}
//大小
int Size_LinkList(LinkList list)
{
	if (NULL == list)
	{
		return;
	}
	struct LList* mylist = (struct LList*)list;
	return mylist->size;
}
//销毁链表
void Destroy_LinkList(LinkList list)
{
	if (NULL == list)
	{
		return;
	}
	struct LList* mylist = (struct LList*)list;
	//辅助指针变量
	struct LinkNode* pCurrent = mylist->header.next;
	while (pCurrent != NULL)
	{
		//先缓存下一个节点的地址
		struct LinkList* pNext = pCurrent->next;
		//释放当前节点
		free(pCurrent);

		pCurrent = pNext;
	}
	mylist->header.next = NULL;
	mylist->size = 0;
	free(list);
	list = NULL;
}

单向链表（版本一）.c

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"LinkList.h"

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

int myCompare(void* d1, void* d2)
{
	struct Person* p1 = (struct Person*)d1;
	struct Person* p2 = (struct Person*)d2;

	/*if (strcmp(p1->name, p2->name) == 0 && p1->age == p2->age)
	{
		return 1;
	}
	return 0;*/
	//两者等价
	return strcmp(p1->name, p2->name) == 0 && p1->age == p2->age;
}

void myPrint(void* data)
{
	struct Person* person = (struct Person*)data;
	printf("Name:%s Age:%d\n", person->name, person->age);
}

void test201()
{
	//创建链表
	LinkList list = Init_LinkList();

	//创建数据
	struct Person p1 = { "aaa",10 };
	struct Person p2 = { "bbb",20 };
	struct Person p3 = { "ccc",30 };
	struct Person p4 = { "ddd",40 };
	struct Person p5 = { "eee",50 };
	struct Person p6 = { "fff",60 };
	struct Person p7 = { "ggg",70 };

	//插入数据
	insert_LinkList(list, 0, &p1);//p1
	insert_LinkList(list, 0, &p2);//p2 p1
	insert_LinkList(list, 1, &p3);// p2 p3 p1
	insert_LinkList(list, 2, &p4);// p2 p3 p4 p1
	insert_LinkList(list, 20, &p5);// p2 p3 p4 p1 p5
	insert_LinkList(list, 3, &p6);// p2 p3 p4 p6 p1 p5
	insert_LinkList(list, 6, &p7);// p2 p3 p4 p6 p1 p5 p7

	//遍历打印
	Foreach_LinkList(list,myPrint);

	//打印链表大小
	printf("-------------------------\n");
	printf("List Size:%d\n", Size_LinkList(list));

	//按位置删除
	RemoveByPos_LinkList(list, 3);// p2 p3 p4 p1 p5 p7
								  
	//遍历打印
	printf("-------------------------\n");
	Foreach_LinkList(list, myPrint);

	//按值删除
	struct Person pDelPerson = { "ggg",70 };
	RemoveByVal_LinkList(list, &pDelPerson, myCompare);// p2 p3 p4 p1 p5

	//遍历打印
	printf("-------------------------\n");
	Foreach_LinkList(list, myPrint);

	//清空链表
	Clear_LinkList(list);
	//打印链表大小
	printf("-------------------------\n");
	printf("List Size:%d\n", Size_LinkList(list));

	//销毁链表
	Destroy_LinkList(list);

}

int main(void)
{
	test201();

	system("pause");
	return EXIT_SUCCESS;
}

003.单向链表（版本二）思路

版本一的单向链表的缺陷：每次添加和删除元素时都需要开辟堆空间和释放堆空间

版本二思路（代码简单实现）

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct LinkNode
{
	struct LinkNode* next;
};

struct Person
{
	struct LinkNode node;
	char name[64];
	int age;
};

//版本二简单思路，下次实现完整代码
void test301()
{
	struct Person p1 = { NULL,"aaa",10 };
	struct Person p2 = { NULL,"bbb",20 };
	struct Person p3 = { NULL,"ccc",30 };
	struct Person p4 = { NULL,"ddd",40 };
	struct Person p5 = { NULL,"eee",50 };

	struct LinkNode* pp1 = (struct LinkNode*)&p1;
	struct LinkNode* pp2 = (struct LinkNode*)&p2;
	struct LinkNode* pp3 = (struct LinkNode*)&p3;
	struct LinkNode* pp4 = (struct LinkNode*)&p4;
	struct LinkNode* pp5 = (struct LinkNode*)&p5;

	pp1->next = pp2;
	pp2->next = pp3;
	pp3->next = pp4;
	pp4->next = pp5;
	pp5->next = NULL;

	struct LinkNode* pCurrent = pp1;
	while (pCurrent != NULL)
	{
		struct Person* person = (struct Person*)pCurrent;
		printf("Name:%s Age:%d\n", person->name, person->age);

		pCurrent = pCurrent->next;
	}

}


int main(void)
{
	test301();
	system("pause");
	return EXIT_SUCCESS;
}
xu_06161014
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C语言 -- 动态数组&链表
woshizuopie的博客
09-04 948
将数组开辟到堆区，实现动态扩展。① 用户的数据类型无法确定；② 用户的数据无法确定创建在堆区还是栈区；③ 不管数据在堆区还是栈上，都是在内存中，就会有地址，只需维护数据的地址就行。
数据结构之单向链表
先锋小牛
05-29 249
概述     线性结构是一种最简单且常用的数据结构。线性结构的基本特点是节点之间满足线性关系。本章讨论的动态数组、链表、栈、队列都属于线性结构。他们的共同之处，是节点中有且只有一个开始节点和终端节点。按这种关系，可以把它们的所有节点排列成一个线性序列。但是，他们分别属于几种不同的抽象数据类型实现，它们之间的区别，主要就是操作的不同。线性表是零个或者多个数据元素的有限序列，数据元素之间是有顺序的，
数据结构-单向链表两个版本
qq_35426012的博客
09-14 227
思路：用一个结构体做链表头，里面统计链表的大小，获取这个链表头就是获取整个链表 链表是一种常用的数据结构，它通过指针将一些列数据结点，连接成一个数据链。相对于数组，链表具有更好的动态性（非顺序存储） 链表的优点： 1 不需要一块连续的存储区域 2 删除和插入某个元素效率高 缺点：随机访问元素效率低 linklist.h
数据结构与算法--疫苗预约管理系统(C语言)
weixin_52270842的博客
05-07 5040
目录 前言 1·设计目的 2·设计内容与要求 2·1·课题要求 3·设计思路 3·1 关键问题描述 3·2 解决方法 4·具体实现 总结 前言 这是之前在学习数据结构与算法的时候，写的疫苗预约管理系统；也可以作为参考供大家使用；当然很多功能都还没有加入，后面有时间会陆续更新； 1·设计目的 通过疫苗预约管理系统这项目，来测试自身对本学期所学的知识是否掌握牢靠。同时，培养我们自身综合运用所学知识，发现，提出，分析和解决实际问题，锻炼实践能力的重要环节，对我们自身实际工作能力的具体
c语言提高day01——四区
m0_68176382的博客
08-11 351
c语言提高day01——四区
Unity游戏开发基础之数据结构部分
小星AI
11-09 4349
数据结构，编程基础，找工作必备，提升代码上限
数据结构与算法之美
william_n的博客
08-31 4864
1.介绍 数据结构和算法解决的是如何更省、更快地存储和处理数据的问题. 数据结构和算法是相辅相成的。数据结构是为算法服务的，算法要作用在特定的数据结构之上。 因此，我们无法孤立数据结构来讲算法，也无法孤立算法来讲数据结构。比如，因为数组具有随机访问的特点，常用的二分查找算法需要用数组来存储数据。但如果我们选择链表这种数据结构，二分查找算法就无法工作了，因为链表并不支持随机访问。数...
spark-day04-依赖关系-持久化-分区器-数据结构
AlphaG的博客
02-15 2539
一：依赖关系 1：依赖和血缘关系介绍 rdd.todebugstring：打印血缘关系 rdd.dependencies：打印依赖关系 2：保存血缘关系 3：OneToOne依赖---窄依赖 4：shuffle依赖--宽依赖 新的RDD的一个分区的数据依赖于旧的RDD多个分区的数据，这个依赖称之为shuffle依赖。 5：窄依赖的任务 6：宽依赖的任务 7：任务分类 1： 一个main方法里面可能有多...
超硬核十万字！全网最全 数据结构 代码，随便秒杀老师/面试官，我说的
热门推荐
hebtu666
04-20 11万+
本文代码实现基本按照《数据结构》课本目录顺序，外加大量的复杂算法实现，一篇文章足够。能换你一个收藏了吧？
数据结构v1——顺序表的基本操作之插入操作
Vicky
11-30 2929
时，在函数体内不需要改变主调函数中的实参变量的值，只需读取主调函数中的实参变量的值，因此函数形参定义为变量，采用值传递。，i-1上的结点，依次后移到位置n，n-1，…C++语言中用引用作函数的形参，被调函数对形参做的任何操作都影响了主调函数中的实参变量值，而操作一个变量比操作一个指针要简单的多，为了便于算法描述，本书函数参数传递机制采用有两种方式：值传递和引用传递。如果需要将函数中变化的形式参数的值反映在实际参数中，在C语言的实现中，就需要通过指针变量作形式参数，接收变量的地址，达到修改实参变量值的目的。
数据结构_day01_算法引入
12-21
在标题"数据结构_day01_算法引入"中，我们可以理解这是关于数据结构和算法的初步学习，主要关注算法的引入。描述中的"最坏时间复杂度"提到了性能分析，这在算法设计中至关重要，因为它决定了程序在处理大量数据时的...
【数据结构】Day51
08-03
【数据结构】Day51和Day52的内容主要聚焦在数据结构中的树，特别是二叉树和表达式树。在这一部分的学习中，我们将深入理解这两种重要的数据结构及其应用。 4.2 叉树（Binary Trees） 二叉树是一种特殊类型的树，...
笔记day01.docx
09-10
而C语言则是面向过程的，侧重于通过结构化的代码块实现功能，这在大型项目中可能导致数据安全性和代码复用性的不足。 【C++的优势】 1. 底层开发能力：C++允许开发者更接近硬件，适用于需要高效性能的场景。 2. ...
文件IO_day1.pdf
02-21
赫夫曼编码是一种变长编码方式，可以压缩数据，提高数据存储和传输效率。 2.Linux文件IO Linux文件IO是操作系统提供的一种函数，用于访问系统资源，例如读取文件、创建进程等。这些函数都是经过测试的，如果某个...
python刷题day2.rar
04-23
Python编程语言在IT行业中广泛应用，尤其在数据处理、自动化脚本和Web开发等领域。这个名为"python刷题day2.rar"的压缩包似乎...通过深入理解和实践这些题目，可以增强对数据结构、算法的理解，以及提高问题解决能力。
x264 编码器 CAVLC 熵编码原理分析：cavlc_block_residual_internal函数
人生只有一次，不妨大胆一点～～
07-22 372
x264 编码器 CAVLC 熵编码原理分析：cavlc_block_residual_internal函数
C语言 之 理解指针（3）
fallzzzzz的博客
07-21 1092
本章主要内容是对数组名的理解、使⽤指针访问数组、⼀维数组传参的本质、⼆级指针、指针数组、指针数组模拟⼆维数组
C 观察者模式 Demo
最新发布
我要出家当道士
07-24 323
本文简单介绍了观察者模式，并提供了 C Demo
C语言——字符串中sizeof和strlen的辨析
weixin_45720999的博客
07-19 434
在C语言中，sizeof 和 strlen 函数在处理字符串时有明显不同的作用和结果。使用不当很容易出现错误......
C语言数据结构：代码示例与逻辑思维培养
本资源是一份关于数据结构的教程，特别关注C语言的应用，以清华大学出版社的《数据结构》教材为基础。学习内容包括但不限于基础的数据结构概念，如队列、栈、二叉树和图，以及常用的排序算法如冒泡排序。通过实例，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值