数据结构基础——单链表

最新推荐文章于 2022-09-07 17:07:31 发布
最新推荐文章于 2022-09-07 17:07:31 发布
阅读量428 收藏 1
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 单链表 链表 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XXXTENTAC1ON/article/details/115313839
版权
这篇博客详细介绍了单链表的概念，包括链表与顺序表的区别以及单链表在存储上的特性。文章讨论了两种不同的实现方式：头结点和头指针，并提供了相关操作的声明与实现，如初始化、插入、删除、查找、反转等。此外，还对比了头结点和头指针在记录链表信息和方法实现上的差异。
摘要由CSDN通过智能技术生成

单链表

单链表的概念

链表和顺序表的区别：

​ 链表在逻辑存储上是连续的，在物理存储上是不连续的。

​ 单链表属于链表中的一种，每一个存储数据的节点除了存储数据本身之外，还需要存储其直接后继结点的地址。

在这里插入图片描述

例： 32位系统存储10个整形（int 4个字节）数据：

​ 顺序表存储： 总共需要的堆区空间： 40个字节

​ 单链表存储： 总共需要的堆区空间： 80个字节

单链表的实现

  • 头结点
    在这里插入图片描述

  • 头指针 – 在实现代码中会使用二级指针
    在这里插入图片描述

头结点单链表

1、结构声明

typedef int DataType;

typedef struct Node
{
	// 数据类型
	union   //   联合体  当使用其中一个时 就不能使用另一个
	{
		DataType  data;  //  存储有效数据的
		int       length;  //  头结点使用，来存储结点个数的
	};
	
	// 结点指针类型
	struct Node *next;
}LinkList;

2、方法的声明

//  初始化
void  InitLinkList(LinkList *head);

//  销毁
void DestroyLinkList(LinkList *head);

//  插入
bool InsertLinkList(LinkList *head, DataType value, int pos);

bool  InsertLinkListHead(LinkList *head, DataType value);

bool  InsertLinkListRear(LinkList *head, DataType value);

//  bool  InsertLinkListValueBefore();
//  bool  InsertLinkListValueAfter();

//  删除
bool  DeleteLinkList(LinkList *head, int pos);

bool  DeleteLinkListHead(LinkList *head);

bool  DeleteLinkListRear(LinkList *head);

bool  DeleteLinkListValue(LinkList *head, DataType value);

//  判空 

bool EmptyLinkList(LinkList *head);

//  长度
int  GetLength(LinkList *head);

//  显示

void ShowLinkList(LinkList *head);
3、方法的实现
#include "head_list.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

static LinkList *ApplyNode(DataType value, LinkList *point)
{
	LinkList *new_node = (LinkList *)malloc(sizeof(LinkList));
	if (new_node == NULL) return NULL;

	new_node->data = value;
	new_node->next = point;

	return new_node;
}

//  初始化
void  InitLinkList(LinkList *head)
{
	if (head == NULL)  exit(0);

	head->length = 0;
	head->next = NULL;
}

//  长度
int  GetLength(LinkList *head)
{
	if (head == NULL) exit(0);

	return head->length;
}

//  插入
bool InsertLinkList(LinkList *head, DataType value, int pos)
{
	if (head == NULL)  exit(0);

	if (pos < 0 || pos > GetLength(head))  return false;

	//  找pos位置的前面一个结点
	LinkList  *p = head;
	while (pos)
	{
		p = p->next;
		pos--;
	}

	LinkList *new_node = ApplyNode(value, p->next);
	if (new_node == NULL) return false;

	p->next = new_node;
	head->length++;
	return true;
}

bool  InsertLinkListHead(LinkList *head, DataType value)
{
	if (head == NULL) exit(0);

	LinkList *new_node = ApplyNode(value, head->next);
	if (new_node == NULL) return false;

	head->next = new_node;
	head->length++;
	return true;
}

bool  InsertLinkListRear(LinkList *head, DataType value)
{
	if (head == NULL) exit(0);

	return InsertLinkList(head, value, GetLength(head));
}

//  删除
bool  DeleteLinkList(LinkList *head, int pos)
{
	if (head == NULL) exit(0);

	if (pos < 0 || pos >= GetLength(head)) return false;

	LinkList *p = head;

	while (pos)
	{
		p = p->next;
		pos--;
	}
	//  需要删除的节点是p的后继结点
	LinkList *q = p->next;
	p->next = q->next;
	free(q);
	head->length--;
	return true;
}

bool  DeleteLinkListHead(LinkList *head)
{
	if (head == NULL);

	return DeleteLinkList(head, 0);
}

bool  DeleteLinkListRear(LinkList *head)
{
	if (head == NULL) exit(0);

	return DeleteLinkList(head, GetLength(head) - 1);
}

//  考虑有重复值的情况
bool  DeleteLinkListValue(LinkList *head, DataType value)
{
	if (head == NULL)  exit(0);

	LinkList *p = head;
	LinkList *q = head->next;

	while (q != NULL)
	{
		if (q->data == value)
		{
			p->next = q->next;
			free(q);
			q = p->next;
			head->length--;
		}
		else
		{
			p = q;
			q = q->next;
		}
	}

	return true;
}

bool EmptyLinkList(LinkList *head)
{
	if (head == NULL)  exit(0);

	return head->length == 0;
}

void ShowLinkList(LinkList *head)
{
	if (head == NULL) exit(0);

	LinkList *p = head->next;

	while (p != NULL)
	{
		printf("%d  ", p->data);
		p = p->next;
	}

	printf("\n");
}

//  销毁
void DestroyLinkList(LinkList *head)
{
	if (head == NULL) exit(0);

	while (!EmptyLinkList(head))
	{
		DeleteLinkListHead(head);
	}
}

LinkList *FindOfK(LinkList *head, int k)  //  0< k <= length
{
	if (head == NULL)  return NULL;

	if (k <= 0 || k > head->length)  return NULL;

	int pos = head->length - k + 1;

	LinkList *p = head;

	while (pos)
	{
		p = p->next;
		pos--;
	}

	return p;
}

//  不能直接获得length的情况
LinkList *FindOfK2(LinkList *head, int k)
{
	if (head == NULL)  return NULL;

	if (k <= 0)  return NULL;

	LinkList *p = head;

	while (k && p != NULL)
	{
		p = p->next;
		k--;
	}

	if (p == NULL)  return NULL;

	LinkList *q = head;
	while (p != NULL)
	{
		p = p->next;
		q = q->next;
	}

	return q;
}

bool DeleteOfNode(LinkList *head, LinkList *p)
{
	if (head == NULL || p == NULL)  return false;

	if (p->next == NULL) return DeleteLinkListRear(head);

	LinkList *q = p->next;   
	p->data = q->data;
	p->next = q->next;

	free(q);
	return true;
}

void Reverse(LinkList *head)
{
	if (head == NULL || head->next == NULL)  return;

	LinkList *p = NULL;
	LinkList *q = head->next;
	LinkList *s = q->next;

	while (q != NULL)
	{
		q->next = p;
		p = q;
		q = s;
		if (s != NULL) s = s->next;
	}

	head->next = p;
}

LinkList *IsIntersect(LinkList *head1, LinkList *head2)
{
	if (head1 == NULL || head2 == NULL)  return NULL;

	LinkList *p = head1;
	LinkList *q = head2;

	if (head1->length > head2->length)
	{
		for (int i = 0; i < head1->length - head2->length; i++)
		{
			p = p->next;
		}
	}
	else
	{
		for (int i = 0; i < head2->length - head1->length; i++)
		{
			q = q->next;
		}
	}

	while (p != q)
	{
		p = p->next;
		q = q->next;
	}

	return p;
}


LinkList *IsIntersect2(LinkList *head1, LinkList *head2)
{
	if (head1 == NULL || head2 == NULL)  return NULL;

	LinkList *p = head1;
	LinkList *q = head2;

	while (p != q)
	{
		if (p != NULL) p = p->next;
		else  p = head2;
		if (q != NULL) q = q->next;
		else q = head1;
// 		p = p != NULL ? p->next : head2;
// 		q = q != NULL ? q->next : head1;
	}

	return p;
}

LinkList *IsLoop(LinkList *head)
{
	if (head == NULL) return NULL;

	LinkList *fast = head;  //  快指针
	LinkList *slow = head;  //  慢指针

	while (fast != NULL && fast->next != NULL)
	{
		fast = fast->next->next;
		slow = slow->next;
		if (slow == fast) break;
	}

	if (fast == NULL || fast->next == NULL)  return NULL;

	LinkList *p = fast;
	LinkList *q = head;

	while (p != q)
	{
		p = p->next;
		q = q->next;
	}

	return p;
}

头指针单链表

​ 头指针和头结点实现的区别：

​ 1、记录链表的类型不同，头指针是一个4字节的指针，记录第一个存储数据的节点的地址。头结点是一个结构体变量，使用这个变量的next域记录第一个存储数据的节点的地址，头结点中的data域可以使用联合体方式记录链表的长度。

​ 2、各个操作方法的定义不同。如果是头指针实现，则方法中接受这个链表的类型就必须是二级指针。头结点实现的这些方式使用一级指针就OK。

1、结构的定义
typedef  int  DataType;

typedef struct Node
{
  	DataType    data;    //   记录本结点存储的数据
    struct Node  *next;  //   记录下一个结点的地址
}LinkList;
2、方法的声明
// 初始化
void  InitLinkList(LinkList **phead);
//  插入
bool InsertLinkList(LinkList **phead, DataType value, int pos);

bool InsertLinkListHead(LinkList **phead, DataType value);

bool InsertLinkListRear(LinkList **phead, DataType value);

//  删除
bool DeleteLinkList(LinkList **phead, int pos);

bool DeleteLinkListHead(LinkList **phead);

bool DeleteLinkListRear(LinkList **phead);

//  长度
int GetLength(LinkList **phead);
//  判空
bool  Empty(LinkList **phead);
//  销毁
void  DestroyLinkList(LinkList **phead);

//  显示
void  ShowLinkList(LinkList **phead);
3、方法的实现
#include "list.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>


static LinkList *ApplyNewNode(DataType value, LinkList *next)
{
	LinkList *new_node = (LinkList *)malloc(sizeof(LinkList));
	if (new_node == NULL)  exit(0);

	new_node->data = value;
	new_node->next = next;

	return new_node;
}


void  InitLinkList(LinkList **phead)  //  phead中存储的值就是main方法中的phead变量的地址
{
	if (phead == NULL)  exit(0);

	*phead = NULL;
}

int GetLength(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	int length = 0;

	LinkList *p = *phead;

	while (p != NULL)
	{
		length++;
		p = p->next;
	}

	return length;
}

bool InsertLinkList(LinkList **phead, DataType value, int pos)
{
	if (phead == NULL)  exit(0);

	if (pos < 0 || pos > GetLength(phead))  return false;

	//  在头指针的后面插入新结点，头插法必须特殊处理： 因为只有在这需要修改头指针的值
	if (pos == 0)  return InsertLinkListHead(phead, value);//  头插


	LinkList *p = *phead;

	while (pos > 1)
	{
		p = p->next;
		pos--;
	}

	//  while循环结束后，就需要在p所指向的结点的后面插入新结点

	/* 
		LinkList *new_node = ApplyNewNode(value, p->next); 
		p->next = new_node;
	*/
	p->next = ApplyNewNode(value, p->next);
	return true;
}

bool InsertLinkListHead(LinkList **phead, DataType value)
{
	if (phead == NULL)  exit(0);

	*phead = ApplyNewNode(value, *phead);

	return true;
}

bool InsertLinkListRear(LinkList **phead, DataType value)
{
	if (phead == NULL)  exit(0);

	//  链表本身是空的，尾插相当于头插
	if (Empty(phead))  return InsertLinkListHead(phead, value);

	LinkList *p = *phead;

	while (p->next != NULL)  p = p->next;  //  while循环结束后，p就是最后一个结点

	p->next = ApplyNewNode(value, NULL);
	return true;
}

bool  Empty(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	if (*phead == NULL)  return true;

	return false;
}


void  ShowLinkList(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	LinkList *p = *phead;

	while (p != NULL)
	{
		printf("%d  ", p->data);
		p = p->next;
	}

	printf("\n");
}

bool DeleteLinkList(LinkList **phead, int pos)
{
	if (phead == NULL)  exit(0);

	if (pos < 0 || pos >= GetLength(phead))  return false;

	if (pos == 0)  return DeleteLinkListHead(phead);

	LinkList *p = *phead;  //  p指向的是第一个数据结点

	while (pos > 1)
	{
		p = p->next;
		pos--;
	}

	//  while循环结束后，要删除的结点时p->next
	LinkList *q = p->next;
	p->next = q->next;
	free(q);
	return true;
}

bool DeleteLinkListHead(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	if (Empty(phead))  return false;

	LinkList *p = *phead;

	*phead = p->next;
	free(p);
	return true;
}

bool DeleteLinkListRear(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	if (Empty(phead))  return false;

	LinkList *front = NULL;
	LinkList *p = *phead;

	while (p->next != NULL)
	{
		front = p;
		p = p->next;
	}

	if (front == NULL)  return DeleteLinkListHead(phead);

	front->next = NULL;
	free(p);
	return true;
}

void  DestroyLinkList(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	while (!Empty(phead))
	{
		DeleteLinkListHead(phead);
	}
}

头指针单链表操作时的转化：

​ 因为头结点实现的单链表相比于头指针实现的单链表，操作时特殊情况能少一些。在实现一些头指针的单链表的操作时，可以虚拟构建出一个头结点。

bool  Funaction(LinkList  **phead)
{
	LinkList  *head = (LinkList *)malloc(sizeof(LinkList));  //  虚拟出来的头结点
    head->next = *phead;
    
    LinkList *p = head;  //  p指向的头结点
    LinkList  *q = p->next;  
    
    while(q->next != NULL)
    {
        p = q;
        q = q->next;
    }
    
    p->next = q->next;
    free(q);
    
    *phead = head->next;
    free(head);
}
悲伤土豆拌饭
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
了解Redis数据结构——链表（linked-list）
monkey_wei的博客
05-06 486
链表结构是Redis中的一个常用的结构，他可以存储多个字符串，而且它是有序的，能够存储40多亿个节点。Redis链表是双向的，因此既可以从左到右，也可以从右到左遍历它存储的节点，链表结构如下： 由于它是双向链表，所以它的读性能就会相对丧失，而插入和删除就会显得很便利。它的增删操作与双向链表同。 因为是双向链表结构，所以Redis链表命令分为左操作和右操作两种命令，左操作意味着是从左到右，右操作意...
Python数据结构：链表
Python宋宋的专栏
06-06 3586
链表是一种在存储单元上非连续、非顺序的存储结构。数据元素的逻辑顺序是通过链表中的指针链接次序实现。链表是由一系列的结点组成，结点可以在运行时动态生成。每个结点包含两部分：数据域与指针域。数据域存储数据元素，指针域存储下一结点的指针。单向链表也叫单链表，是链表中最简单的形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。head 保存首地址，item 存储数据，next 指向下一结点地址。链表失去了序列的随机读取优点，同时链表增
链表中的节点占多大内存空间
张亮校的专栏
02-28 1903
为了让我记住这一点,因此写下来.是占用一个地址空间大小,32位机上是4个字节.
细说链式存储结构
热门推荐
Ron.Zheng
10-13 2万+
提起链式存储结构，其与数组是两个非常基础的数据结构，每当提到链式存储结构时，一般情况下我们都会将其与数组放到一块儿来比较。 对于数组与链表，从结构上来看，数组是需要一块连续的内存空间来存储数据，对内存的要求非常高，比如说我们申请一个100M大小的数组，而如果我们的内存可用空间大于100M，但是没有连续的100M可用空间，那即便是我们的内存空间充足，在申请空间时也会申请失败。 而对于链表来说，他对内...
链表
章全蛋的博客
09-28 201
链表 相比数据，链表是一种稍微复杂一点的数据结构。我们先从底层的存储结构上来看一看： 数组需要一块连续的内存空间来存储，对内存的要求比较高。如果我们申请 100MB 大小的数组，当内存中没有连续的、足够大的存储空间时，即便内存的剩余总可用空间大于 100MB ，仍然会申请失败。 而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存块串联起来使用，所以如果我们申请的是 100MB 大小的链表，根本不会有问题。 最常见的三种链表结构有： 单向链表 双向链表 循环链表 链表通过指针将
数据结构——单链表实验
06-15
熟悉单链表的定义，单链表的建立方法及相关基本操作，理解单链表的基本思想，能够根据实际情况选择合适的存储结构。 2.实验内容 1、利用头插法或尾插法建立单链表 2、对已建立的单链表实现插入、删除等基本操作； 3...
数据结构学习笔记——单链表
12-21
数据结构是计算机科学中至关重要的基础概念，它们用于有效地组织和管理数据，以便进行高效的存储、检索和操作。本文将深入探讨单链表这一常见数据结构，并与其他数据结构如数组进行对比。 单链表是一种线性数据结构...
数据结构——单链表.zip
09-16
本资料包"数据结构——单链表.zip"专注于单链表的实现，特别针对严蔚敏教授的数据结构教材内容进行了完整的编程实现。下面，我们将深入探讨单链表及其相关操作。 单链表是一种线性数据结构，每个元素称为节点，每个...
数据结构实验报告——单链表.docx
12-05
数据结构实验报告主要关注了单链表这一基本的数据结构，并通过一系列操作展示了如何利用单链表来处理集合的运算，如排序、合并、求交集和差集。实验的目的是提高对数据结构的理解和实际编程能力。 单链表是一种线性...
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
【数据结构】数组 VS 链表
最新发布
weixin_72504310的博客
09-07 1018
数组 VS 链表
单链表小结
qq_44625505的博客
07-04 401
==第一次学数据结构，大家相互交流，欢迎批评指正。谢谢~
链表到底比较占用空间还是节省空间
m0_48198797的博客
07-21 2669
链表到底比较占用空间还是节省空间 从两个角度来分析: 单从数据存储来说，顺序表(如数组)只需要存储 数据，而链表每个节点除了存储数据外还需要存储下一个节点地址(也就是指向)，所以说从这个角度来说链表是比较占用空间的； 单从空间分配来讲，顺序表必须一开始就分配好连续的空间，可能空间有剩余造成浪费，而链表则不会出现这种情况，链表是有几个节点就有几个值，用到了再分配，不会造成空间浪费，起到了节省空间的作用。 ...
C 数据结构实验之链表一：顺序建立链表 SDUT
zhangzhaolin12的博客
01-12 3809
Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Sample Input 8 12 56 4 6 55 15 33 62 Output 12 56 4 6 55 15 33 62 Hint 不得使用数组！ 一定要知道链表是怎样连接的，...
数据结构-单链表
qq_28551705的博客
08-01 163
单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素. 以结点来表示,每个结点是由元素 + 指针组成. 以结点的序列表示线性表称作线性链表(单链表),单链表是链式存取的结构. 单链表设头指针head指向开始结点 /** 创建一个单链表 */ typedef struct _Sample_List { int Data; struct _Sample...
将非空单链表中的数据域值最大的那个链结点移至链表的末尾的算法
CaryaLiu的专栏
11-27 1万+
已知非空线性链表第1个链结点的指针为list，在算法的设计中需要用到4个LinkList指针，q 用来记录域值最大的那个链结点，s 用来记录域值最大的那个链结点的直接前驱结点，p用来遍历整个链表，r 用来记录在遍历过程中当前正在比较的链结点的直接前驱结点。在算法设计中需要分两步，第一步是要找到最大值结点，第二步是要将最大值结点移动至链表的末尾（如果最大值结点不是末尾结点）。 在将最大值结点移动到
Leetcode02-两数相加-基于python
weixin_41444880的博客
10-31 138
1题目描述 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 2审题与思路 1：本题主要考察了链表，链表是数据结构中一种非常重要的结构。关于python中链表的相关知识可以参考此篇文章 https://www.cnblogs.com/king-ding/p/pythonchaintable.
数据结构：单链表的操作
碧瑶的博客呀
07-05 408
单链表要实现增删改查，反转，置空等功能 分为三部分test.c ,SList.c, SList.h 以下为源代码： test.c #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include "Slist.h" #include <stdlib.h> void menu() { printf("** 1....
多项式相加算法实现及数据结构——单链表解析
"两个多项式的相加算法-数据结构课件" 在数据结构中，多项式是一种常见的数学概念，它可以通过链表结构来有效地表示和处理。这篇课件主要讲解了如何实现两个多项式的相加算法，这个算法是基于链表的数据结构设计的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值