数据结构与算法-链表

已于 2022-10-04 03:54:26 修改
阅读量389 收藏
点赞数
分类专栏： 数据结构/算法 文章标签： 链表 数据结构 单向链表
于 2022-10-03 00:08:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ProgrammersFighting/article/details/127140956
版权

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

一、数据结构与算法-单向链表

  优点：删除和插入方便。
  缺点：查找某元素时需遍历链表中的所有结点。

1.1 简单单向链表

   1.1.1 简单链表的存储结构

     简单单向链表的存储结构如下图所示，
在这里插入图片描述

   1.1.2 在链表指定位置处插入元素

     具体步骤如下所示：
        1) 创建指向头结点的辅助结点(LinkNode *pCurrent)
        2) 将辅助结点移动至指定位置处
        3) 插入元素；注意：插入元素时需要新开辟结点(LinkNode *newNode)存放需要插入的数据。
     插入步骤如下图所示，

在这里插入图片描述
     实现代码如下所示：

// 在给定位置处插入元素
void Insert_LinkList(LinkList* list, void* data, int pos) {
	// 判断链表和数据是否为空
	if (list == NULL || data == NULL) return;
	// 判断插入位置是否正常
	if (pos < 0 || pos>list->size) pos = list->size; // 若插入位置异常，则在链表尾部插入元素
	// 创建辅助结点，定位到pos指向的结点
	LinkNode* pCurrentLinkNode = list->head;
	for (int i = 0; i < pos; i++) {
		pCurrentLinkNode = pCurrentLinkNode->next;
	}
	// 插入数据
	//   1) 开辟新结点(newNode)，保存数据
	LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
	newNode->data = data;
	//  2) 更改结点的next指针，插入数据
	newNode->next = pCurrentLinkNode->next;
	pCurrentLinkNode->next = newNode;
	// 元素个数加1
	list->size++;
}
   1.1.3 在指定位置删除元素

     具体步骤如下所示：
        1) 创建指向头结点的辅助结点(LinkNode pCurrent)
        2) 将辅助结点移动至指定位置处
        3) 删除结点中的元素；注意：删除元素时需要创建一个指向被删除结点的临时指针(tempNode)，结点中元素删除完毕后，需要释放该结点所占用的内存，否则会造成内存泄漏。
     删除步骤如下图所示，在这里插入图片描述

// 删除指定位置的元素
void RemoveValueByPos_LinkList(LinkList* list, int pos) {
	// 判断链表和数据是否为空
	if (list == NULL) return;
	if (pos < 0 || pos>list->size) return;
	
	// 创建辅助结点，查找pos位置处的结点
	LinkNode* pCurrentLinkNode = list->head;
	for (int i = 0; i < pos; i++) {
		pCurrentLinkNode = pCurrentLinkNode->next;
	}
	// 缓存当前结点，否则会造成内存泄露
	LinkNode* newNode = pCurrentLinkNode->next;
	pCurrentLinkNode->next = newNode->next;
	// 释放缓存结点
	free(newNode);
	list->size--;
}
   1.1.4 完整代码
// 头文件 LinkList.h
#ifndef LINKLIST_H
#define LINKLIST_H
#include<stdlib.h>
#include<stdio.h>
#include<string.h>

// 打印函数
typedef void (*PRINT)(void*);
// 比较函数
typedef int (*COMPARE)(void*, void*);

// 定义链表结点
typedef struct LINKNODE {
	// 数据域
	void* data;
	// 指针域
	struct LINKNODE* next;
}LinkNode;

// 链表
typedef struct LINKLIST {
	// 头结点
	LinkNode* head;
	// 元素的个数
	int size;
}LinkList;

// 链表初始化
LinkList* Init_LinkList();

// 在给定位置处插入元素,插入成功返回1，插入失败返回-1
void Insert_LinkList(LinkList* list, void* data, int pos);

// 删除指定位置的元素
void RemoveValueByPos_LinkList(LinkList* list, int pos);

// 删除特定值的元素
void RemoveValueByValue_LinkList(LinkList* list, void* data, COMPARE compare);

// 查找，根据传入的值查找，并返回第一个为data的位置pos
int Find_LinkList(LinkList* list, void* data, COMPARE compare);

// 第一个元素的结点
void* Front_LinkLsit(LinkList* list);

// 返回链表中元素的个数
int Size_LinkList(LinkList* list);

// 打印链表
void Print_LinkList(LinkList* list, PRINT print);
// 释放链表空间
void FreeSpace_LinkList(LinkList* list);

#endif // !LINKLIST_H

// LinkList.c
#include"LinkList.h"
// 链表初始化
LinkList* Init_LinkList() {
	LinkList* list = (LinkList*)malloc(sizeof(LinkList));
	if (list != NULL) {
		list->size = 0;
		list->head = (LinkNode*)malloc(sizeof(LinkNode));
		if (list->head != NULL) {
			list->head->data = NULL;
			list->head->next = NULL;
		}
	}
	else {
		printf("内存分配失败!");
		return NULL;
	}
	return list;
}


// 在给定位置处插入元素,插入成功返回1，插入失败返回-1
void Insert_LinkList(LinkList* list, void* data, int pos) {
	// 判断链表和数据是否为空
	if (list == NULL || data == NULL) return;
	// 判断插入位置是否正常
	if (pos < 0 || pos>list->size) pos = list->size; // 若插入位置异常，则在链表尾部插入元素
	// 创建辅助结点，定位到pos指向的结点
	LinkNode* pCurrentLinkNode = list->head;
	for (int i = 0; i < pos; i++) {
		pCurrentLinkNode = pCurrentLinkNode->next;
	}
	// 插入数据
	//     开辟新结点，保存数据
	LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
	newNode->data = data;
	newNode->next = pCurrentLinkNode->next;
	pCurrentLinkNode->next = newNode;
	// 元素个数加1
	list->size++;
}

// 删除指定位置的元素
void RemoveValueByPos_LinkList(LinkList* list, int pos) {
	// 判断链表和数据是否为空
	if (list == NULL) return;
	if (pos < 0 || pos>list->size) return;
	
	// 创建辅助结点，查找pos位置处的结点
	LinkNode* pCurrentLinkNode = list->head;
	for (int i = 0; i < pos; i++) {
		pCurrentLinkNode = pCurrentLinkNode->next;
	}
	// 缓存当前结点，否则会造成内存泄露
	LinkNode* newNode = pCurrentLinkNode->next;
	pCurrentLinkNode->next = newNode->next;
	// 释放缓存结点
	free(newNode);
	list->size--;
}

// 删除特定值的元素
void RemoveValueByValue_LinkList(LinkList* list, void* data, COMPARE compare) {
	if (list == NULL || data == NULL) return;
	// 创建辅助结点，遍历整个链表，删除第一个与data相等的元素
	LinkNode* pCurrent = list->head;
	while (pCurrent) {
		if (compare(pCurrent->next->data, data) == 1) {
			// 删除pCurrent->next结点
			// 简历缓存结点
			LinkNode* newNode = pCurrent->next;
			pCurrent->next = newNode->next;
			// 释放缓存结点
			free(newNode);
			list->size--;
			return;
		}
		// 结点指针指向下一个结点
		pCurrent = pCurrent->next;
	}
}

// 查找，根据传入的值查找，并返回第一个为data的位置pos
int Find_LinkList(LinkList* list, void* data, COMPARE compare) {
	if (list == NULL || data == NULL) return -1;
	// 创建辅助结点,跳过头结点
	LinkNode* pCurrent = list->head->next;
	int pos = 0, flag = -1;
	while (pCurrent) {
		if (compare(pCurrent->data, data) == 1) {
			return flag = pos;
		}
		// 移动位置
		pos++;
		// 将指向当前结点的指针移向下一个结点
		pCurrent = pCurrent->next;
	}
	return flag;
}
// 第一个元素的结点
void* Front_LinkLsit(LinkList* list) {
	if (list == NULL) return NULL;
	return list->head->next->data;
}

// 返回链表中元素的个数
int Size_LinkList(LinkList* list) {
	if (list == NULL) return -1;
	return list->size;
}

// 打印链表
void Print_LinkList(LinkList* list, PRINT print) {
	if (list == NULL) return;
	// 创建辅助结点
	LinkNode* pCurrent = list->head->next;
	while (pCurrent) {
		// 打印结点中的数据
		print(pCurrent->data);
		// 移动辅助当前结点指向的位置
		pCurrent = pCurrent->next;
	}
}

// 释放链表空间
void FreeSpace_LinkList(LinkList* list) {
	if (list == NULL) return;
	// 先释放链表中每个结点的空间
	LinkNode* pCurrent = list->head;
	while (pCurrent) {
		// 缓存下一个结点
		LinkNode* pNext = pCurrent->next;
		// 释放当前结点
		free(pCurrent);
		pCurrent = pNext->next;
	}
	free(list);
}

// main.c
#include"LinkList.h"
#include<string.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 }, p5 = {"eee", 60};

	// 初始化数组
	LinkList* list = Init_LinkList();

	// 插入结构体数据
	Insert_LinkList(list, &p1, 0);
	Insert_LinkList(list, &p2, 0);
	Insert_LinkList(list, &p3, 0);
	Insert_LinkList(list, &p4, 0);
	Insert_LinkList(list, &p5, 0);
	// 删除前的数组
	printf("删除结点前的链表：\n");
	Print_LinkList(list, myPrint);

	// 根据位置删除元素
	RemoveValueByPos_LinkList(list, 0);
	// 删除后的数组
	printf("删除0号结点后的链表：\n");
	Print_LinkList(list, myPrint);

	// 根据值删除数组
	Person p6 = { "aaa", 20 };
	RemoveValueByValue_LinkList(list, &p6, compare);
	printf("删除数据为{name：aaa, age: 20}的结点后的链表：\n");
	Print_LinkList(list, myPrint);
	
	// 根据值查找位置
	printf("{name：ccc, age: 40}所在位置：%d\n", Find_LinkList(list, &p3, compare));
	//RemoveValueByPos_LinkList(list, Find_LinkList(list, &p3, compare));
	//Print_LinkList(list, myPrint);

	printf("\n=====================\n");
	// 数组大小
	printf("链表中元素个数：%d\n", Size_LinkList(list));

	//返回第一个结点
	Person* ret = (Person*)Front_LinkLsit(list);
	printf("姓名：%s, 年龄：%d", ret->name, ret->age);
	
	// 释放链表空间
	FreeSpace_LinkList(list);
	
	return 0;
}
   1.1.5 运行结果

     运行结果如下所示，
在这里插入图片描述

1.2 改进后的链表

   1.2.1 改进链表的存储结构

  改进后的链表结点(LinkNode)仅包含指针域(LinkNode *next)，无数据域。用链表维(LinkList)护链表结点(LinkNode)和元素数量(size)。链表结构如下所示，
在这里插入图片描述
  值得注意的是，放入链表中的数据必须包含一个链表结点，通过链表结点将数据串联串联，具体如下所示。
在这里插入图片描述
  相较于1.1小节的链表，改进后的链表在插入元素无需开辟新结点存储数据，仅需改变结点的next指针即可。

   1.2.2 向改进后的链表插入元素

  向改进后的链表插入元素如下图所示，
在这里插入图片描述

// 向链表中指定位置插入元素
void Insert_LinkList(LinkList* list, LinkNode* node, int pos) {
	// 判断边界情况
	if (list == NULL || node == NULL) return;
	if (pos < 0 || pos >list->size) pos = list->size; // 插入到链表末尾
	// 找到pos位置处对应的结点
	//    1) 创建辅助结点
	LinkNode* pCurrent = &list->head;
	for (int i = 0; i < pos; i++) {
		pCurrent = pCurrent->next;
	}
	//    2) 将传入的node,插入到链表中
	node->next = pCurrent->next;
	pCurrent->next = node;
	// 与包含指针与和数据域的结点相比，更加节省空间，不用新开辟结点保存数据
	//    3) 将链表中的元素数量+1
	list->size++;
}

二、参考链接

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

Shell-We
关注
专栏目录
数据结构与算法 -- 链表
u012967763的专栏
08-21 629
一点一滴学算法，算法从入门到放弃
链表 - 数据结构与算法 - 链表算法
11-01
链表
C语言 单向链表
xjm956的博客
07-15 291
单向链表
数据结构day08---动态数组和单项链表
charon的博客
08-26 168
目录1.数据结构概念2.动态数组3.单向链表 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
数据结构与算法-链表（练习一）
LoveXming的博客
03-12 1479
数据结构与算法-链表练习
数据结构与算法-链表（练习二）
LoveXming的博客
03-12 1753
C++ 链表刷题练习 删除链表元素
数据结构与算法-链表(力扣附链接)
2301_76249062的博客
02-08 1644
数据结构刷题
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
Java数据结构与算法——双向链表
★★光亭★★
03-11 6170
Java数据结构与算法——双向链表
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 2万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-环形链表I
07-25
链表实战题目4 - 链表入环的第一个节点给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-两两交换链
07-25
# 将第一个节点指向第三个节点# 第二个节点指向第一个节点# 节点first指向第二个节点# 当前节点后移动，记得a.next是节点3，相当于跳了一个节点，往后
数据结构和算法-思维导图.pdf
05-26
以上是根据文件的标题、描述、标签和部分预览内容总结出的数据结构与算法知识点。这些知识点是IT行业中软件开发人员必备的基础知识，广泛应用于软件设计、算法实现、系统优化等众多领域。掌握这些知识点能够帮助IT...
通用型函数——冒泡排序
2401_84654619的博客
10-29 417
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
数据结构和算法-动态规划(3)-经典问题
qq_36115196的博客
10-30 840
动态规划(Dynamic Programming): 计算并存储小问题的解， 并将这些解组合成大问题的解。
java-数据结构
2301_80708315的博客
10-30 1004
如果使用 left < right 作为条件，那么在最后一次迭代中，当 left 和 right 相邻时（即 left = right - 1），循环就会提前终止，从而可能错过目标元素（如果它正好位于 left 或 right 指向的位置）。left ==right 意味着它们指向的元素也会参与比较，left < right 只意味着middle指向的元素参与比较。l为总循环次数，当元素在最右边与最左边时的循环次数不一致。eg 当我的数组为{1，23，45，77，123}时我查找12时就会返回。
【数据结构篇】探索堆的算法的巧妙
最新发布
braveact的博客
11-02 569
⽤剩余的N-K个元素依次与堆顶元素来⽐较，不满⾜则替换堆顶元素 ，然后再将交换进去后的元素向下调整（保证这k个元素始终是堆），最后将剩余N-k个元素依次与堆顶元素⽐完之后，堆中剩余的K个元素就是所求的前k个最⼩或者最⼤的元素。对于Top-K问题，能想到的最简单直接的⽅式就是排序，但是：如果数据量⾮常⼤，排序就不太可取了 (可能数据都不能⼀下⼦全部加载到内存中)。依次将堆顶最大的数据与最后一个（不断发生变化）元素交换，每次都是将最大的数据放最后，可以想象一下，就是升序了。前k个最⼩的元素，则建⼤堆。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值