数据结构与算法-链表

已于 2022-10-04 03:54:26 修改
阅读量374 收藏
点赞数
分类专栏： 数据结构/算法 文章标签： 链表 数据结构 单向链表
于 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 601
一点一滴学算法，算法从入门到放弃
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-环形链表I
07-25
链表实战题目4 - 链表入环的第一个节点给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，我们使用整数 pos
C语言 单向链表
xjm956的博客
07-15 278
单向链表
数据结构day08---动态数组和单项链表
charon的博客
08-26 162
目录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 1441
数据结构与算法-链表练习
数据结构与算法-链表（练习二）
LoveXming的博客
03-12 1720
C++ 链表刷题练习 删除链表元素
数据结构与算法-链表(力扣附链接)
2301_76249062的博客
02-08 1627
数据结构刷题
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 34万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
Java数据结构与算法——双向链表
★★光亭★★
03-11 6143
Java数据结构与算法——双向链表
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 2万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
cailingling721#data-structures-and-algorithms#数据结构和算法-链表实战-两两交换链
07-25
# 将第一个节点指向第三个节点# 第二个节点指向第一个节点# 节点first指向第二个节点# 当前节点后移动，记得a.next是节点3，相当于跳了一个节点，往后
数据结构和算法-思维导图.pdf
05-26
以上是根据文件的标题、描述、标签和部分预览内容总结出的数据结构与算法知识点。这些知识点是IT行业中软件开发人员必备的基础知识，广泛应用于软件设计、算法实现、系统优化等众多领域。掌握这些知识点能够帮助IT...
数据结构与算法-顺序表（链表篇）
09-09
在IT领域，数据结构与算法是计算机科学的基础，它们直接影响到程序的效率和设计。本资源专注于"顺序表"中的"链表"部分，这是一组相关数据元素的集合，其内部组织方式不同于传统的数组。链表不依赖于内存中的连续空间...
Pandas_数据结构详解
2201_75415080的博客
09-19 1213
DataFrame是一个表格型的==结构化==数据结构，它含有一组或多组有序的列（Series），每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame是Pandas中最基本的数据结构，Series的许多属性和方法在DataFrame中也一样适用.两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。两个Series之间计算时，索引值相同的元素之间会进行计算；索引值不同的元素的计算结果会用NaN值(缺失值)填充。
数据结构：二叉树（一）
2303_78940834的博客
09-21 747
ps：偷懒了几天，接着更新。
数据结构——二叉树堆的专题
imaima666的博客
09-19 791
如果有一个关键码的集合K = {K0 ，K1 ，K2 ，K3…) i = 0，1， 2…，则称为(或将。
数据结构—树
最新发布
2301_80151359的博客
09-22 426
在文件系统中，树结构被广泛应用，它通过父结点和子结点之间的关系来表示不同层级的文件和文件夹之间的关联。树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系。若一个结点含有子结点，则这个结点称为其子结点的父结点；如上图：A是B的父结点。以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙。一个结点含有的子树的根结点称为该结点的子结点；1.有一个特殊的结点，称为根结点，根结点没有前驱结点。具有相同父结点的结点互称为兄弟结点(亲兄弟)；
数据结构与算法-线性链表解析
在计算机科学中，线性链表是一种基本的数据结构，属于数据结构与算法的范畴。线性链表的实现通常使用链式存储结构，它由一系列节点组成，每个节点包含数据元素和指向下一个节点的指针。在二级公共基础的课程中，这一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值