数据结构与算法 | 链表

已于 2022-03-28 20:38:57 修改
阅读量326 收藏 2
点赞数 3
分类专栏： 数据结构与算法 文章标签： 数据结构 链表 c语言 算法 线性表
于 2020-02-07 21:56:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35423154/article/details/104215824
版权

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
在这里插入图片描述
对于表，图，栈，队列，树等数据结构，我们采用链式和顺序结构都可以实现。
而链表又分为很多种，这一次先介绍最基础的链表
因为链表的空间并不连续，所以我们无需像顺序表一样考虑到表的容量，实现起来也更为简单,同时，这次实现的链表是不带头的单向链表，因为没有头节点，也没有返回值，我们就需要直接对指针进行操作，传递参数时就需要传二级指针

数据结构
typedef struct ListNode
{
	DATATYPE data;
	struct ListNode* next;
}ListNode;
实现的接口
void ListPrint(ListNode* list);
//打印链表
void ListPushBack(ListNode** list, DATATYPE x);
//头删
void ListPushFront(ListNode** list, DATATYPE x);
//头插
void ListPopBack(ListNode** list);
//尾删
void ListPopFront(ListNode** list)
//头插
void ListInsert(ListNode** pos, DATATYPE x);
//指定位置插入
void ListErase(ListNode** pos);
//指定位置删除
void ListDestory(ListNode** list);
//销毁链表
ListNode* ListFind(ListNode** list, DATATYPE x);
//查找链表元素
打印链表
void ListPrint(ListNode* list)
{
	if (list == NULL)
	{
		printf("表空\n");
		return;
	}
	ListNode* cur = list;

	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
头插
void ListPushFront(ListNode** list, DATATYPE x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->data = x;
	newnode->next = NULL;

	newnode->next = *list;
	*list = newnode;
}

头插：即每次在表的头部插入，所以我们每次只需要将原头节点设为插入节点的next节点，然后再将这个插入的节点作为头节点即可
如图所示，当我们依次插入1，2，3，4时
在这里插入图片描述

尾插
void ListPushBack(ListNode** list, DATATYPE x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));

	newnode->data = x;
	newnode->next = NULL;

	if (*list == NULL)
	{
		*list = newnode;
	}

	else
	{
		ListNode* tail = *list;

		while (tail->next)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

尾插：即我们常用的方式，实现方法是先找到链表的最后一个节点，然后将他的next节点设为插入的节点，再让插入的节点的下一个next节点为空即可
在这里插入图片描述

头删
void ListPopFront(ListNode** list)
{
	if (NULL == *list)
		return;
	ListNode* next = (*list)->next;
	free(*list);
	(*list) = next;
	
}

头删:我们先用next指针来保存首部的下一个节点，然后再将首部删除，使之前的next指针成为新的首部，即可实现头删

尾插
void ListPopBack(ListNode** list)
{
	if (NULL == *list)
	{
		printf("表空\n");
		return;
	}
	else if ((*list)->next == NULL)
	{
		free(*list);
		*list = NULL;
	}
	else
	{
		ListNode* prev = NULL, * tail = *list;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		if (prev)
			prev->next = NULL;
	}
}

尾删：尾删的实现要稍微比头删麻烦一些，因为我们的这个链表并不是双向的，所以当我们遍历到最后一个节点的时候无法访问上一个节点，我们就需要用一个prev来保存上一个节点的地址，当我们遍历到最后一个节点的时候，直接释放掉这个一个节点，然后让prev指针的下一个节点指向空即可实现

链表查找
ListNode* ListFind(ListNode** list, DATATYPE x)
{	
	ListNode* cur = *list;

	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	
	return NULL;
}

遍历链表查找元素

在Pos位置插入
void ListInsert(ListNode** pos, DATATYPE x)
{
	if (NULL == (*pos))
		return;

	ListNode* cur = (ListNode*)malloc(sizeof(ListNode));
	cur->data = x;

	cur->next = (*pos)->next;
	(*pos)->next = cur;
}

在Pos位置插入：让插入的元素的next指向pos位置的next，然后再让pos的next指向这个元素即可

在Pos位置删除
void ListErase(ListNode** pos)
{
	if (NULL == (*pos) || NULL == (*pos)->next)
		return;

	ListNode* next = (*pos)->next;
	(*pos)->next = next->next;
	free(next);
	next = NULL;
}

在Pos位置删除：这里指的是删除pos位置的后一个元素，即让pos指针的next指向他原本的next的next，也就是pos指针往后两个的位置

销毁链表
void ListDestory(ListNode** list)
{
	ListNode* cur = *list;

	while (cur)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*list = NULL;
}

具体代码：
头文件：

#pragma once

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#define _CRT_SECURE_NO_WARNINGS
#define LISTSIZE 10

typedef int DATATYPE;
typedef struct ListNode
{
	DATATYPE data;
	struct ListNode* next;
}ListNode;

void ListPrint(ListNode* list);
void ListPushBack(ListNode** list, DATATYPE x);
void ListPushFront(ListNode** list, DATATYPE x);
void ListPopBack(ListNode** list);
void ListPopFront(ListNode** list);
void ListInsert(ListNode** pos, DATATYPE x);
void ListErase(ListNode** pos);
void ListDestory(ListNode** list);
ListNode* ListFind(ListNode** list, DATATYPE x);

函数实现文件：

#include "LinkList.h"

void ListPrint(ListNode* list)
{
	if (list == NULL)
	{
		printf("表空\n");
		return;
	}
	ListNode* cur = list;

	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

void ListPushBack(ListNode** list, DATATYPE x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));

	newnode->data = x;
	newnode->next = NULL;

	if (*list == NULL)
	{
		*list = newnode;
	}

	else
	{
		ListNode* tail = *list;

		while (tail->next)
		{
			tail = tail->next;
		}

		tail->next = newnode;
	}
}

void ListPushFront(ListNode** list, DATATYPE x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->data = x;
	newnode->next = NULL;

	newnode->next = *list;
	*list = newnode;
}

void ListPopBack(ListNode** list)
{
	if (NULL == *list)
	{
		printf("表空\n");
		return;
	}
	else if ((*list)->next == NULL)
	{
		free(*list);
		*list = NULL;
	}
	else
	{
		ListNode* prev = NULL, * tail = *list;
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		if (prev)
			prev->next = NULL;
	}
}


void ListPopFront(ListNode** list)
{
	if (NULL == *list)
		return;
	ListNode* next = (*list)->next;
	free(*list);
	(*list) = next;
	
}

ListNode* ListFind(ListNode** list, DATATYPE x)
{	
	ListNode* cur = *list;

	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		else
		{
			cur = cur->next;
		}
	}
	
	return NULL;
}

void ListDestory(ListNode** list)
{
	ListNode* cur = *list;

	while (cur)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	*list = NULL;
}

void ListInsert(ListNode** pos, DATATYPE x)
{
	if (NULL == (*pos))
		return;

	ListNode* cur = (ListNode*)malloc(sizeof(ListNode));
	cur->data = x;

	cur->next = (*pos)->next;
	(*pos)->next = cur;
}

void ListErase(ListNode** pos)
{
	if (NULL == (*pos) || NULL == (*pos)->next)
		return;

	ListNode* next = (*pos)->next;
	(*pos)->next = next->next;
	free(next);
	next = NULL;
}
凌桓丶
关注
专栏目录
数据结构与算法 -- 链表
u012967763的专栏
08-21 595
一点一滴学算法，算法从入门到放弃
数据结构与算法-链表
wdfscsdn2015的博客
09-23 958
在讲述链表之前让我们对数据结构进行一个简单的回顾：我们知道，数据结构指的是描述实际问题中各个数据项节点之间的前后逻辑结构关系，即要么是线性结构（即某一数据项的前继节点和后继节点有且只有一个）要么是非线性结构（即某一数据节点的前驱或者后继节点不止一个）。在确定了实际数据项的数据结构之后，我们要采用某种存储方式对其进行存储，常见的数据结构的存储方式有：顺序存储、链式存储、散列存储以及索引存储。每一种存...
数据结构与算法——链表
LoveXming的博客
03-12 1600
数据结构与算法——链表
数据结构与算法—链表
weixin_49757069的博客
05-22 333
链表 链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。 链表与数组的对比： 相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。在数组中，我们可以直接访问任何元位置的任何元素，而要想访问链表中间的一个元素，则需要从起点（表头）开始迭代链表直到找到所需的元素。 class Node { constructor(element) { this.el
《数据结构与算法》之链表
菜鸟的向往
05-14 302
最近因为在学习《数据机构与算法》，所以有一段时间没有更新博客了。现在通个写一篇关于链表的博客和一个demo来巩固一下最近的学习，把理论转换为“实战”。 链表结构五花八门，其中最常见的链表结构有单链表、双向链表和循环链表。顺便一提，如果在面试中涉及到到链表，面试官老喜欢问你一句：数组和链表的区别。只要我们理解掌握了什么是链表才能从结构、存储数据、插入、删除上的差异来回答。 在这篇文章先说一下单链表。 首先手写一个单链表 要写一个单链表就必须弄清楚它的数据结构，来一张图看下它长什么样子 清楚了它的数据结构
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
《数据结构与算法》课程上机实验二（链表）_链表_fruitd55_C++_数据结构与算法_
10-04
在计算机科学中，数据结构与算法是至关重要的基础，它们直接影响到程序的效率和性能。本次上机实验主要关注的是链表，一种常用的数据结构，它在C++中有着广泛的应用。链表不同于数组，其元素不是连续存储的，而是...
JavaScript数据结构与算法之链表
11-26
链表是一种常见的数据结构，也属于线性表，但不会按线性的顺序来储存数据。而是在每一个节点中，储存了下一个节点的指针。可以看图理解。(有C语言基础的可能比较好理解)。 使用链表结构可以克服数组需要预先知道数据...
JS数据结构与算法.pdf
最新发布
11-01
JS 数据结构与算法.pdf 本书主要介绍了 JavaScript 语言的基础知识，包括数据结构和算法。以下是该书的详细知识点： 一、JavaScript 基础知识 * 变量和数据类型 * 运算符和控制结构 * 函数和对象 * 数组和字符串 ...
【数据结构与算法】链表
一以贯之的努力 不得懈怠的人生
09-01 3378
数组和链表是所有数据结构的基础，链表是很重要的两种线性结构之一链表可以分为单链表、双链表、循环单链表、循环双链表四种，每一种又可以分为有头和无头两种单链表就是相邻两个节点之间只有一个指针连接，而有头单链表就是第一个节点（也就是头节点）不存储数据，后面才存储数据的链表，无头单链表就是头节点存储有数据请注意：实际运用中，有头链表是不用的至于循环单链表和循环双链表，区别就在于循环链表的尾节点会指向第一个节点。
JavaScript实现单向链表
雨的印记的博客
03-01 363
JavaScript实现单向链表 javascript 数据结构与算法源码 目录JavaScript实现单向链表一、单向链表简介二、封装单向链表类2.0.创建单向链表类2.1.append(element)2.2.toString()2.3.insert(position,element)2.4.get(position)2.5.indexOf(element)2.6.update(position,element)2.7.removeAt(position)2.8.其他方法2.9.完整实现 一、单向链表简
数据结构与算法--链表
gg13213的博客
10-05 146
链表链表移除链表元素反转链表 链表 单链表：链表是指通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域、一个是指针域（存放指向下一个节点指针），最后一个节点的指针域指向null（空指针）。 链表的入口节点称为链表的头节点，即head。 双链表：每一个节点有两个指针域，一个指向下一个节点，另一个指向上一个节点。 双链表既可以向前查询也可以向后查询。 循环列表：链表首尾相连。 链表的存储方式： 链表在内存中不是连续分布的，链表通过指针域的指针链接在内存中的各个节点。即链表散乱分布在内存中的某地址
数据结构与算法：链表
weixin_45777469的博客
07-10 267
1.链表介绍 1、链表的是以节点的方式来存储的 2、每个节点包含data域，next域：指向下一个数据 3、链表的各个节点不一定是连续存储 4、链表分为带头结点的列表和不带头结点的列表，根据需求来定 2.单向链表的创建 1.先创建一个head头结点，作用就是表示单链表的头 2.后面我们每添加一个节点，就直接加入链表的最后 ......
JavaScript数据结构与算法：链表详解
在JavaScript中，链表是一种重要的数据结构，它与数组不同，不依赖于内存中的连续位置来存储数据。链表的核心思想是每个数据单元（节点）包含两部分：实际数据和指向下一个节点的引用。这样的设计使得链表在插入和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

凌桓丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值