数据结构day08---动态数组和单项链表

最新推荐文章于 2023-09-25 16:40:00 发布
最新推荐文章于 2023-09-25 16:40:00 发布
阅读量155 收藏 1
点赞数
分类专栏： C++学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43588190/article/details/108213725
版权

目录

1.数据结构概念

在这里插入图片描述
在这里插入图片描述

2.动态数组

2.1 线性表基本概念
在这里插入图片描述
2.2 线性表的顺序存储（动态数组）
在这里插入图片描述
在这里插入图片描述

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>//可计算偏移量

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

//初始化数组
struct dynamicArray* init_dynamicArray(int capacity) {
	if (capacity <= 0)
		return NULL;
	struct dynamicArray* arr = malloc(sizeof(struct dynamicArray));
	if (NULL == arr)
		return NULL;
	arr->capacity = capacity;
	arr->addr = malloc(sizeof(void*) * arr->capacity);
	arr->size = 0;
	return arr;
}

//插入元素
void* insert_dynamicArray(struct dynamicArray* arr, int pos, void* data) {
	//存储数据的地址data
	if (NULL == arr)
		return;
	if (NULL == data)
		return;
	if (pos<0 || pos>arr->size)
		pos = arr->size;
	//判断空间是否足够
	if (arr->size >= arr->capacity) {
		//申请一块更大的内存空间
		int newCapacity = arr->capacity * 2;
		void** newSpace = malloc(sizeof(void*) * newCapacity);
		//将原来空间的数据拷贝到新空间
		memcpy(newSpace, arr->addr, sizeof(void*) * arr->capacity);
		//释放原来空间的内存
		free(arr->addr);
		//更新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 remove_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 removeValue_dynamicArray(struct dynamicArray* arr, void* data, int(*compare)(void*, void*)) {
	//如果只有前两个地址形参，无法比较类型
	if (NULL == arr)
		return;
	if (NULL == data)
		return;
	if (NULL == compare)
		return;
	for (int i = 0; i < arr->size; ++i) {
		if (compare(arr->addr[i], data)) {
			//如果比较后两个元素相同，则删除该位置的元素
			remove_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 myPrint(void* data) {
	struct Person* person = (struct Person*)data;
	printf("Name:%s Age:%d\n", person->name, person->age);
}

void myCompare(void* d1, void* d2) {
	struct Person* p1 = (struct Peson*)d1;
	struct Person* p2 = (struct Peson*)d2;
	return strcmp(p1->name, p2->name) == 0 && p1->age == p2->age;
}

void test(){
	//创建动态数组
	struct dynamicArray* da = init_dynamicArray(5);
	//数组添加元素
	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);

	printf("capacity:%d\n", da->capacity);
	insert_dynamicArray(da, 100, &p6);//3 5 4 2 1 6
	printf("capacity:%d\n", da->capacity);

	forEach_dynamicArray(da, myPrint);

	printf("-----------------------------\n");
	remove_dynamicArray(da, 2);//3 5 2 1 6
	forEach_dynamicArray(da, myPrint);
	printf("-----------------------------\n");
	struct Person pDel = { "aaa",10 };
	removeValue_dynamicArray(da, &pDel, myCompare);
	forEach_dynamicArray(da, myPrint);

	//销毁
	destroy_dynamicArray(da);
}

int main(){
	test();
	return 0;
}

在这里插入图片描述

3.单向链表

版本一
在这里插入图片描述

//linkList.h
#pragma once
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>//可计算偏移量
#include <stdbool.h>

//为了在C++中能调用C写的函数
#ifdef __cplusplus
extern "C" {
#endif
	//链表节点数据类型
	struct linkNode {
		void* data;//数据域
		struct linkNode* next;
	};

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

	typedef void* linkList;//定义类型
	typedef void(*FOREACH)(void*);
	typedef int(*COMPARE)(void*, void*);//回调函数
	//初始化链表
	linkList* init_linkList();
	//插入节点
	void insert_linkList(linkList list, int pos, void* data);
	//遍历链表
	void forEach_linkList(linkList list, FOREACH myForEach);
	//按位置删除
	void remove_linkList(linkList list, int pos);
	//按值删除
	void removeValue_linkList(linkList list, void* data, COMPARE compare);
	//清空链表
	void clear_linkList(linkList list);
	//大小
	int getSize_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 - 1) {
		pos = myList->size;
	}
	//查找插入位置
	struct linkNode* pCur = &(myList->header);//指向头结点
	for (int i = 0; i < pos; ++i) {
		pCur = pCur->next;
	}

	//创建新节点
	struct linkNode* newNode = malloc(sizeof(struct linkNode));
	newNode->data = data;
	newNode->next = NULL;
	//新节点插入到链表中
	newNode->next = pCur->next;
	pCur->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* pCur = myList->header.next;
	while (pCur != NULL)
	{
		myForEach(pCur->data);
		pCur = pCur->next;
	}
}

//按位置删除
void remove_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* pCur = &(myList->header);
	for (int i = 0; i < pos; ++i) {
		pCur = pCur->next;
	}
	//先保存待删除节点
	struct linkNode* pDel = pCur->next;
	//重新建立待删除节点的前驱和后继节点关系
	pCur->next = pDel->next;
	//释放删除节点内存
	free(pDel);
	pDel = NULL;
	myList->size--;
}

//按值删除
void removeValue_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* pCur = pPrev->next;
	while (pCur != NULL)
	{
		if (compare(pCur->data, data)) {
			//返回真则找到了
			pPrev->next = pCur->next;
			//释放删除节点内存
			free(pCur);
			pCur = NULL;
			myList->size--;
			break;
		}
		pPrev = pCur;
		pCur = pCur->next;
	}
}

//清空链表
void clear_linkList(linkList list) {
	if (NULL == list)
		return;
	//辅助指针变量
	struct LList* myList = (struct LList*)list;
	struct linkNode* pCur = myList->header.next;
	while (pCur != NULL) {
		//缓存下一节点的地址
		struct linkNode* pNext = pCur->next;
		//释放当前节点内存
		free(pCur);
		pCur = pNext;
	}
	myList->header.next = NULL;
	myList->size = 0;
}

//大小
int getSize_linkList(linkList list) {
	if (NULL == list)
		return -1;
	struct LList* myList = (struct LList*)list;
	return myList->size;
}

//销毁链表
void destroy_linkList(linkList list) {
	if (NULL == list)
		return;
	//清空链表
	clear_linkList(list);
	free(list);
	list = NULL;
}

//main.c
#include"linkList.h"
struct Person {
	char name[64];
	int age;
};

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

int myCompare(void* d1, void* d2) {
	struct Person* p1 = (struct Person*)d1;
	struct Person* p2 = (struct Person*)d2;
	return strcmp(p1, p2) == 0 && p1->age == p2->age;
}

void test() {
	//创建链表
	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 };
	
	//插入数据
	insert_linkList(list, 0, &p1);
	insert_linkList(list, 0, &p2);//2 3 1
	insert_linkList(list, 1, &p3);
	insert_linkList(list, 2, &p4);//2 3 4 1
	insert_linkList(list, 20, &p5);//2 3 4 1 5
	insert_linkList(list, 3, &p6);//2 3 4 6 1 5

	//打印数据
	forEach_linkList(list, myPrint);
	printf("------------------------------\n");
	printf("List Size:%d\n", getSize_linkList(list));
	remove_linkList(list, 3);
	printf("------------------------------\n");
	forEach_linkList(list, myPrint);

	struct Person pDel = { "eee",50 };
	removeValue_linkList(list, &pDel, myCompare);
	printf("------------------------------\n");
	forEach_linkList(list, myPrint);

	//清空链表
	clear_linkList(list);
	printf("------------------------------\n");
	printf("List Size:%d\n", getSize_linkList(list));

	//销毁链表
	destroy_linkList(list);
}

int  main()
{
	test();
	return 0;
}

在这里插入图片描述
版本二
在这里插入图片描述

#pragma once
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>//可计算偏移量
#include <stdbool.h>

//链表节点数据结构
struct linkNode {
	struct linkNode* next;//每一个节点预留四个字节的指针
};

//链表结构体
struct LList {
	struct linkNode header;
	int size;
};

typedef void* linkList;

//初始化链表
linkList init_linkList() {
	struct LList* list = malloc(sizeof(struct LList));
	if (NULL == list)
		return 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;
	struct linkNode* myNode = (struct linkNode*)data;
	if (pos<0 || pos>myList->size)
		pos = myList->size;
	//找位置，找到pos位置的前一个位置
	struct linkNode* pCur = &(myList->header);
	for (int i = 0; i < pos; ++i) {
		pCur = pCur->next;
	}
	//数据插入链表
	myNode->next = pCur->next;
	pCur->next = myNode;
	myList->size++;
}

void forEach_linkList(linkList list, void(*myForeach)(void*)) {
	if (NULL == list)
		return;
	if (NULL == myForeach)
		return;
	struct LList* myList = (struct LList*)list;
	struct linkNode* pCur = myList->header.next;
	while (pCur != NULL) {
		myForeach(pCur);
		pCur = pCur->next;
	}
}

//删除节点
void remove_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* pCur = &(myList->header);
	for (int i = 0; i < pos; ++i) {
		pCur = pCur->next;
	}
	//缓存待删除节点
	struct linkNode* pDel = pCur->next;
	//重新建立待删除节点的前驱和后继节点关系
	pCur->next = pDel->next;
	myList->size--;
}

void destroy_linkList(linkList list) {
	if (NULL == list)
		return;
	free(list);
	list = NULL;
}

struct Person {
	//这里若改为*node，则变成了4个字节，当为双向链表8个字节时，会改变用户数据
	struct linkNode node;
	char name[64];
	int age;
};

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

void test() {
	//初始化链表
	linkList list = init_linkList();

	//创建数据
	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 };

	//插入数据
	insert_linkList(list, 0, &p1);
	insert_linkList(list, 0, &p2);
	insert_linkList(list, 0, &p3);
	insert_linkList(list, 0, &p4);
	insert_linkList(list, 0, &p5);

	//遍历
	forEach_linkList(list, myPrint);

	//删除
	remove_linkList(list, 3);

	printf("----------------------\n");
	forEach_linkList(list, myPrint);

	//销毁
	destroy_linkList(list);
}

int main() {
	test();
	return 0;
}

在这里插入图片描述

chaRon522
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态数组（栈式链表）
09-28
可以自动扩容的栈式链表，也叫动态数组，支持链表操作的增，查，删，改功能，此代码为博主原创，仅供大家学习讨论。
动态数组和链表
05-27
老师上课做的ppt，个人觉得挺详细的。动态数组和链表感觉有点难！
数据结构及算法：动态数组及链表
m0_55644719的博客
04-24 943
文章目录一.循序表和链表1.线性表二.动态数组1.什么是动态数组2.添加方法3.查4.修改5.删除 一.循序表和链表 1.线性表 线性表是n个具有相同元素的有限序列，线性表是一种实际中广泛使用的数据结构，常见的线性链表：循序表（数组），链表，栈，队列，字符串。也就是多个相同数据类型的元素逻辑上呈直线排列，逻辑上连续。 逻辑连续：1号元素在2号元素之前，2号元素在1号元素之后，这种先后循序指的逻辑上的先后，物理上不一定连续（存储时，不一定就是1在2的前面，不是连续存储），比如链表。 二.动态数组 1.什么是动
来聊聊动态数组ArrayList和LinkList的区别
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
08-03 492
在前文数据结构与算法-单链表/** 最好：O(1)* 最坏：O(n)* 平均：O(n)} else {/** 最好：O(1)* 最坏：O(n)* 平均：O(n)} else {}如果空间使用一段时间并扩容无数次且不进行缩容的话，会出现空间浪费的现象，所以我们需要对其进行缩容的操作由此可知我们很可能会因为不断添加元素导致数组动态扩容的情况，所以我们可以提前调用ensureCapacity顶下最终容量一次性完成动态扩容提高程序执行性能。@Test。
vc++基础班[28]---动态数组及动态链表的讲解
aaa407217484的博客
01-23 301
C++中也有相应的动态数组、动态链表、映射表的模板类，就是STL中的：vector、list、map 他们属于C++标准中的一部分，对于程序的移植性来说也是不错的，但是在MFC编程中使用 CArray、CList、CMap 会更方便一些！ CArray、CList、CMap 的由来？…… ①、数组的基本说明： 数组是固定大小的，相同数据类型的元素的顺序集合，每个元素在数组中...
57春节7天练---Day-1：数组和链表 数组和链表.pdf
04-18
57春节7天练---Day-1：数组和链表 数组和链表.pdf
JavaSE-数组集合和链表集合 数组和链表.docx
04-18
链表集合是一种动态数据结构，与数组相比，它在插入和删除操作方面更加灵活高效。链表集合主要分为两种类型：单链表和双链表。 1. **单链表**：每个节点包含一个数据部分和一个指向下一个节点的指针。这意味着每个...
链表_数据结构--链表_
10-01
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。与数组不同，链表的元素不是在内存中连续存储，而是通过节点之间的引用连接起来。每个节点通常包含两个部分：数据...
链表-使用Python基于链表实现数组栈.zip
最新发布
03-13
因此，题目中提到的“链表-使用Python基于链表实现数组栈”就是将栈的特性与链表的高效插入和删除结合，创建一个更高效的栈数据结构。 为了实现基于链表的数组栈，我们需要定义一个Stack类，包含head（栈顶）属性和...
c语言链表数组-c语言手写单链表实现，数组和链表结构对比小结和个人理解 数组和链表.pdf
04-18
在学习编程语言时，大家常常遇到数组和链表这两种数据结构。今天，我们将深入探讨C语言中链表数组的实现和数组与链表结构的对比，并结合个人理解和实践经验来分析它们的优缺。 一、链表数组的实现 链表是一种常见...
动态数组链表
永远积极向上、永远热泪盈眶、永远豪情满怀、永远坦坦荡荡
09-04 1019
一,扩展数组链表这几个步骤 初始化数组的信息 插入数据 删除数据（位置，数组） 销毁数组 //定义保存数组的信息的结构体 struct ListNode { //保存数组的首地址 void** addr; int Capcatity //数组的长度 int m_size; //数组的大小 } L
动态数组java_数组和链表
weixin_39817012的博客
12-05 224
写在前面：数组和链表是数据结构中最基础的两种结构,其他的都是由这两者转化而来；因此，掌握这两种结构至关重要！下面，时光就带大家来学习一下数组和链表；思维导图：1，什么是线性表？线性表是具有相同类型的n(>=0)个数据元素的有限序列(a0,a1,a2,…,an)，ai是表项，n是表长度；那么为什么要提到线性表呢？因为数组和链表都是线性表的结构，只不过它们的存储方式不一样；根据存储方式...
C语言 -- 动态数组&链表
woshizuopie的博客
09-04 958
将数组开辟到堆区，实现动态扩展。① 用户的数据类型无法确定；② 用户的数据无法确定创建在堆区还是栈区；③ 不管数据在堆区还是栈上，都是在内存中，就会有地址，只需维护数据的地址就行。
【算法基础】数组和链表，动态数组，循环数组，链表的变种
qq_35831906的博客
09-25 706
数组适用于需要随机访问元素和已知大小的情况，具有O(1)的访问时间，常用于排序、查找和矩阵运算等算法。链表适用于频繁插入和删除节点的情况，具有O(1)的插入和删除时间，常用于实现栈、队列、哈希表和高级数据结构，如LRU缓存。
C语言学习（可变数组和链表）
xinxuey的博客
12-05 424
#include<stdio.h> #include<stdlib.h> typedef struct{ int *array; int size; }Array; //定义一个Array类型 Array array_create(int init_size) { //定义一个Array类型的变量并初始化 Array a; a.size=init_size; a.array=(int*)malloc(sizeof(int)*a.size);//分配内存空间 .
关于动态链表和数组的效率
annvily的专栏
06-23 1279
这个问题有点大,要了解它首先必须对系统内存的有所接触,我也只是凭借粗浅的伎俩来谈谈对它们的体会(大家想笑的尽管,不要没事拿它偷着乐) 内存在提取数据时,首先在内存起始位置产生一个指针,它通过数据存储位置的偏移量来寻找地址,再读取数据.(1)由于数组是连续的,因此只要寻找到数组的首地址返回,之后只要从数组的首地址产生用来定位的指针来寻找数    据地址,由于地址是连续的,而且通常偏移量都不大,因此数
1-动态数组
weixin_45093118的博客
11-14 149
1. 数据结构概念 算法的特性 （1）零个或多个输入； （2）一个或多个输出； （3）有穷性，在可接受的时间内得出结果； （4）确定性，不会出现二义性； （5）可行性，执行方法可以实现的。 数据结构分类 逻辑结构 （1）集合：相互之间无关系； （2）线性：一对一关系：如数组、链表； （3）树形：一对多关系：如树； （4）图形：多对多关系：如图； 物理结构 （1）顺序存储：如数组； （2）链式...
自定义一个动态数组（数组，链表两种方法实现）
学习笔记。
07-14 1095
数组实现： import java.util.Arrays; class MyArray<E>{ private E[] elementData; private int size; private final static int DEFAULT_CAPACITY = 10; public MyArray(){ //elementData = (E[]) new Obj...
数组与链表的区别
ConstXiong
03-18 208
存取方式：数组可以顺序存取或者随机存取；链表只能顺序存取 存储位置：数组逻辑上相邻的元素在物理存储位置上也相邻；链表的物理存储位置不确定，一般是分散的 存储空间：链表由于带有指针域，存储密度不如数组大 按序号查找：数组可以随机访问，时间复杂度为 O(1)；链表不支持随机访问，平均需要 O(n)；　 按值查找：若数组无序，数组和链表时间复杂度均为 O(n)，当数组有序时，可以采用二分查找将时...
Python list的实现：数组还是链表？- 数据结构解析
这是因为Python列表提供了随机访问和快速插入/删除等特性，这些都是数组结构的优势。 1.1 数据结构 数据结构是组织和存储数据的方式，它包括数据的集合、数据间的关系以及可应用于数据上的操作。常见的数据结构有数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值