【算法与数据结构】链表

已于 2023-06-30 20:01:28 修改
阅读量542 收藏 1
点赞数
分类专栏： 算法与数据结构 文章标签： 数据结构 链表 算法
于 2023-05-07 19:18:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38362786/article/details/130541499
版权

链表

链表：结构定义

链表是由一串节点串联在一起的，链表的每个节点存储两个信息：数据+下一个节点的地址

在这里插入图片描述
分清楚两个概念：什么是内存内部，什么是程序内部
内存内部： 信息存储在内存空间里的
程序内部： 通过什么信息，去操作结构
如果想操作链表的话，我们依靠的是程序内部的信息，而不是内存内部的信息；所以在操作过程中，这些程序内部信息千万不能丢了，因为如果一旦丢了，那么对于内存内部的信息，就永远失去了访问的权限。

代码

结构定义

typedef struct Node{
	int data;
	struct Node *next;
} Node;

构造节点

Node * getNewNode(int val)
{
	Node *p = (Node*)malloc(sizeof(Node));
	p->data = val;
	p->next = NULL;  // 新的节点的下一个指向空
	return p;
}

删除链表
循环遍历节点，先用一个指针p指向头节点，因为先需要移动到下一个节点，再销毁前一个指针，所以需要一个q指针来记录下一个节点，然后销毁当前节点指针p

void clear(Node *head)
{
	if (head == NULL) return;
	// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
	for (Node *p = head, *q; p; p = q)   // p是当前节点
	{
		q = p->next;   // 先让q指向下一个节点
		free(p);       // 再销毁当前节点
	}
	return;
}

链表：插入元素

插入过程的操作顺序，直接影响了我们是否能正确插入一个元素
程序内部信息：head变量：指向整个链表的头地址，node变量：指向待插入的新节点
需要把4号节点插入到2节点后面
在这里插入图片描述
首先，需要一个指针p, 需要找到待插入位置的前一个元素，即1号节点，p指向1号元素
在这里插入图片描述
然后，让新的节点(4号节点)指向2号元素
在这里插入图片描述
然后，让1号元素指向新的节点(4号元素)：
在这里插入图片描述
此时，在逻辑结构上，就已经完成了插入操作：
在这里插入图片描述

代码

因为这是无头链表结构，在实现插入操作的时候，返回的是完成插入之后新链表的首地址
无头链表插入操作后链表的首地址是可能发生改变的。
第一种情况：链表为空，或者插入的位置是0位置（原来链表头的位置），就会导致整个链表的头地址发生改变 ，直接返回新节点
第二种情况： 链表不为空，且插入位置在0之后，就是一般的插入操作，返回原链表头节点指针
p指针是用来找到待插入指针的前一个元素

Node * insert(Node *head, int pos, int val)
{
	if (pos == 0)
	{ 
		Node *node = getNewNode(val);  // 先创建新节点
		node->next = head;             // 让新节点指向原来的头节点
		return node;                   // 直接返回新节点
	}
	Node *p = head;                               // p找到待插入位置的前一个元素
	for (int i = 1; i < pos; i++) p = p->next;   // p走到待插入位置的前一个位置
	Node *node = getNewNode(val);                 // 创建新节点
	node->next = p->next;                        // 先让新节点的next指向待插入位置的节点，即p->next
	p->next = node;                             // 再让p的next指向新节点
	// 此时逻辑上已经完成了插入的操作
	return head;                               // 返回原链表头节点

}

链表：错误插入

由于链表的插入很容易犯错，这里演示一个错误的插入操作
先找到待插入位置的前一个元素
在这里插入图片描述
正确的插入顺序是，让新的元素指向2号元素；错误的操作是，让1号元素（待插入元素的前一个元素）指向新的元素(4号元素)，那么就会发现2号元素的地址信息丢失了，也就是发生内存泄漏。
内存泄漏： 其实写的所有程序都占用内存空间，2号元素和3号元素，依然占用着我们的内存空间，但在程序中对这段信息没有办法进行操作。
对于中大型需要长期线上运行的系统，需要对内存泄漏的问题及其关注和避免的。

在这里插入图片描述

链表：无头链表

在头部是不存储信息的，所以在链表的头部存储的仅仅是一个指针。
在这里插入图片描述

链表：有头链表

在头部存储信息，在链表的头部存储的是一个节点。只不过这个节点有存储数据的区域，但我们不使用这个区域
虚拟头节点： 一般就是有头链表的头节点
在这里插入图片描述

代码演示

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>



typedef struct Node{
	int data;
	struct Node *next;
} Node;


Node * getNewNode(int val)
{
	Node *p = (Node*)malloc(sizeof(Node));
	p->data = val;
	p->next = NULL;  // 新的节点的下一个指向空
	return p;
}

Node *insert(Node *head, int pos, int val)
{
	if (pos == 0)
	{ 
		Node *node = getNewNode(val);  // 先创建新节点
		node->next = head;             // 让新节点指向原来的头节点
		return node;                   // 直接返回新节点
	}
	Node *p = head;                               // p找到待插入位置的前一个元素
	for (int i = 1; i < pos; i++) p = p->next;   // p走到待插入位置的前一个位置
	Node *node = getNewNode(val);                 // 创建新节点
	node->next = p->next;                        // 先让新节点的next指向待插入位置的节点，即p->next
	p->next = node;                             // 再让p的next指向新节点
	// 此时逻辑上已经完成了插入的操作
	return head;                               // 返回原链表头节点

}


void clear(Node *head)
{
	if (head == NULL) return;
	// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
	for (Node *p = head, *q; p; p = q)   // p是当前节点
	{
		q = p->next;   // 先让q指向下一个节点
		free(p);       // 再销毁当前节点
	}
	return;
}

void output_linklist(Node *head)
{
	// 0   1   2
	// 22->33->55
	int n = 0;
	for (Node *p = head; p; p = p->next) n += 1;   // 先求链表的长度n
	// 打印第一行序号
	for (int i = 0; i < n; i++)
	{
		printf("%3d", i);
		printf("  ");    // 对应链表的->两个字符
	}
	printf("\n");

	// 打印第二行链表
	for (Node *p = head; p; p = p->next)
	{
		printf("%3d", p->data);
		printf("->");
	}
	printf("\n\n");
	return; 


}


int main()
{
	srand(time(0));
    #define MAX_OP 7
	Node *head = NULL;
	for (int i = 0; i < MAX_OP; i++)
	{
		int pos = rand() % (i + 1), val = rand() % 100;    // 这里的第一个pos因为是随机数对1取余，永远都是0
		printf("insert %d at %d to linklist\n", val, pos);
		head = insert(head, pos, val);
		output_linklist(head);

	}
	std::cin.get();
	return 0;
}

输出：
在这里插入图片描述

链表：花式查找操作的实现

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>


#define DL 3
#define STR(n) #n
#define DIGIT_LEN_STR(n) "%" STR(n) "d"



typedef struct Node{
	int data;
	struct Node *next;
} Node;


Node * getNewNode(int val)
{
	Node *p = (Node*)malloc(sizeof(Node));
	p->data = val;
	p->next = NULL;  // 新的节点的下一个指向空
	return p;
}

Node *insert(Node *head, int pos, int val)
{
	if (pos == 0)
	{ 
		Node *node = getNewNode(val);  // 先创建新节点
		node->next = head;             // 让新节点指向原来的头节点
		return node;                   // 直接返回新节点
	}
	Node *p = head;                               // p找到待插入位置的前一个元素
	for (int i = 1; i < pos; i++) p = p->next;   // p走到待插入位置的前一个位置
	Node *node = getNewNode(val);                 // 创建新节点
	node->next = p->next;                        // 先让新节点的next指向待插入位置的节点，即p->next
	p->next = node;                             // 再让p的next指向新节点
	// 此时逻辑上已经完成了插入的操作
	return head;                               // 返回原链表头节点

}


void clear(Node *head)
{
	if (head == NULL) return;
	// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
	for (Node *p = head, *q; p; p = q)   // p是当前节点
	{
		q = p->next;   // 先让q指向下一个节点
		free(p);       // 再销毁当前节点
	}
	return;
}

void output_linklist(Node *head, int flag = 0)
{
	// 0   1   2
	// 22->33->55
	int n = 0;
	for (Node *p = head; p; p = p->next) n += 1;   // 先求链表的长度n
	// 打印第一行序号
	for (int i = 0; i < n; i++)
	{
		// printf("%3d", i);
		printf(DIGIT_LEN_STR(DL), i);
		printf("  ");    // 对应链表的->两个字符
	}
	printf("\n");

	// 打印第二行链表
	for (Node *p = head; p; p = p->next)
	{
		// printf("%3d", p->data);
		printf(DIGIT_LEN_STR(DL), p->data);
		printf("->");
	}
	printf("\n");
	if (flag == 0) printf("\n\n");
	return; 


}

int find(Node *head, int val)  
{
	// 查找，遍历链表的每个节点
	Node *p = head;  // 当前节点指针
	int n = 0;      // 用来记录输出元素个数
	while (p)
	{
		if (p->data == val){
			output_linklist(head, 1);
			int len = n * (DL + 2);      // 空字符个数
			for (int i = 0; i < len; i++) printf(" ");   // 输出前面的空格
			printf("^\n");
			for (int i = 0; i < len; i++) printf(" ");   // 输出前面的空格
			printf("|\n");
			return 1;
		}
		n += 1;
		p = p->next;
	}
	return 0;

}



int main()
{
	srand(time(0));
    #define MAX_OP 7
	Node *head = NULL;
	// 测试插入操作
	for (int i = 0; i < MAX_OP; i++)
	{
		int pos = rand() % (i + 1), val = rand() % 100;    // 这里的第一个pos因为是随机数对1取余，永远都是0
		printf("insert %d at %d to linklist\n", val, pos);
		head = insert(head, pos, val);
		output_linklist(head);

	}

	// 测试查找操作
	int val;
	while (scanf_s("%d", &val)){
		if (!find(head, val)) printf("not found\n");
	}
	std::cin.get();
	return 0;
}

输出链表的生成：
在这里插入图片描述
输出查找操作
在这里插入图片描述

链表：用有头链表改写插入操作

定义一个虚拟头节点，然后定义一个指针p，指向虚拟头节点
让虚拟头节点的下一节点为原来的头指针，此时形成了一个有头链表
然后开始插入操作，一样的，先找到待插入位置的前一个元素位置，这时候因为在0位置前有一个虚拟头节点，所以对于pos=0的情况，就是虚拟头节点本身。
注意：虚拟头节点的下一个节点才是要返回的头节点

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>


#define DL 3
#define STR(n) #n
#define DIGIT_LEN_STR(n) "%" STR(n) "d"



typedef struct Node{
	int data;
	struct Node *next;
} Node;


Node * getNewNode(int val)
{
	Node *p = (Node*)malloc(sizeof(Node));
	p->data = val;
	p->next = NULL;  // 新的节点的下一个指向空
	return p;
}

// 有头链表的插入操作 
Node *insert(Node *head, int pos, int val)
{
	Node newhead, *p = &newhead;   
	newhead.next = head;           // 让虚拟头节点的下一节点为head
	// 此时已经构造了一个有头链表
	for (int i = 0; i < pos; i++) p = p->next;   // 先找到待插入位置的前一位
	Node *node = getNewNode(val);
	node->next = p->next;
	p->next = node;
	return newhead.next;    // 虚拟头节点的下一个节点才是要返回的头节点
}


void clear(Node *head)
{
	if (head == NULL) return;
	// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
	for (Node *p = head, *q; p; p = q)   // p是当前节点
	{
		q = p->next;   // 先让q指向下一个节点
		free(p);       // 再销毁当前节点
	}
	return;
}

void output_linklist(Node *head, int flag = 0)
{
	// 0   1   2
	// 22->33->55
	int n = 0;
	for (Node *p = head; p; p = p->next) n += 1;   // 先求链表的长度n
	// 打印第一行序号
	for (int i = 0; i < n; i++)
	{
		// printf("%3d", i);
		printf(DIGIT_LEN_STR(DL), i);
		printf("  ");    // 对应链表的->两个字符
	}
	printf("\n");

	// 打印第二行链表
	for (Node *p = head; p; p = p->next)
	{
		// printf("%3d", p->data);
		printf(DIGIT_LEN_STR(DL), p->data);
		printf("->");
	}
	printf("\n");
	if (flag == 0) printf("\n\n");
	return; 


}

int find(Node *head, int val)  
{
	// 查找，遍历链表的每个节点
	Node *p = head;  // 当前节点指针
	int n = 0;      // 用来记录输出元素个数
	while (p)
	{
		if (p->data == val){
			output_linklist(head, 1);
			int len = n * (DL + 2) + 1;      // 空字符个数
			for (int i = 0; i < len; i++) printf(" ");   // 输出前面的空格
			printf("^\n");
			for (int i = 0; i < len; i++) printf(" ");   // 输出前面的空格
			printf("|\n");
			return 1;
		}
		n += 1;
		p = p->next;
	}
	return 0;

}



int main()
{
	srand(time(0));
    #define MAX_OP 7
	Node *head = NULL;
	// 测试插入操作
	for (int i = 0; i < MAX_OP; i++)
	{
		int pos = rand() % (i + 1), val = rand() % 100;    // 这里的第一个pos因为是随机数对1取余，永远都是0
		printf("insert %d at %d to linklist\n", val, pos);
		head = insert(head, pos, val);
		output_linklist(head);

	}

	// 测试查找操作
	int val;
	while (scanf_s("%d", &val)){
		if (!find(head, val)) printf("not found\n");
	}
	std::cin.get();
	return 0;
}

链表：循环链表

单向循环链表

单向循环链表：在单向链表的基础上加一个循环结构，循环结构是指最后一个节点指向了第一个节点
注意： 在单向循环链表中的头指针head指向整个链表的最后一个节点
为什么要指向最后一个节点：因为最后一个节点充当着一个实实在在的链表中的节点，也充当着一个虚拟头节点。有了这个虚拟头节点之后，当需要插入节点到链表中时，插入到哪个位置就向后走几步即可
在这里插入图片描述

代码

结构定义
与单向链表的节点定义一样

typedef struct Node{
	int data;
	struct Node *next;
} Node;

构造循环

Node *ConstructLoop(Node *head)   // 构造链表循环
{
	if (head == NULL) return head;
	Node *p = head;
	while (p->next) p = p->next;  // 找到链表的最后一个节点
	p->next = head;   //最后的节点的下一个节点指向头节点
	head = p;         // 头指针指向最后一个节点
	return head;      // 返回头指针
}

删除循环链表
与单向链表的删除一样

void clear(Node *head)        // 删除单向链表
{
	if (head == NULL) return;
	// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
	for (Node *p = head, *q; p; p = q)   // p是当前节点
	{
		q = p->next;   // 先让q指向下一个节点
		free(p);       // 再销毁当前节点
	}
	return;
}

单向循环链表：插入

如果头指针head指向的不是链表最后一个节点，而是第一个节点，那么在插入元素到index=0的位置时，是不是要先找到0位置节点的前一个节点，那就是链表的最后一个节点，也就是说，为了在0位置插入一个节点，还要先遍历完链表的全部节点才能进行插入操作，所以将头指针head设置为链表最后一个节点是合理。在这里插入图片描述
插入在index=0位置后，不需要修改head指向的节点，保持指向为最后一个节点即可。
在这里插入图片描述
插入到链表的最后一个节点的后面，则需要在插入完成后修改head指向的节点
在这里插入图片描述
在这里插入图片描述

代码

Node *insertLoop(Node *head, int pos, int val)
{
	int n = 1;
	Node *q = head->next;
	while (q != head)  // 记录循环链表的长度
	{
		n += 1;
		q = q->next;
	}
	Node *p = head;                              // 当前指针指向头节点，相当于单向链表的虚拟头节点
	for (int i = 0; i < pos; i++) p = p->next;   // 找到待插入位置的前一位
	Node *node = getNewNode(val);

	// 插入操作
	if (pos < n)
	{
		node->next = p->next;
		p->next = node;
		return head;   // 如果插入的位置不是在最后一个节点之后，返回原头指针
	}
	else
	{
		node->next = p->next;
		p->next = node;
		head = node;          // 否则，头指针指向最后一个节点
		return head;
	}
	      
}

链表：双向链表

双向链表： 除了有指向下一个节点的变量next指针之外，还有指向上一个节点的变量pre指针
第一个节点的pre指针指向空地址
最后一个节点的next指针指向空地址
在这里插入图片描述

代码

结构定义

typedef struct BiNode{
	int data;
	struct BiNode *next;
	struct BiNode *pre;
} BiNode;

构造节点

BiNode *getNewBiNode(int val)
{
	BiNode *p = (BiNode*)malloc(sizeof(BiNode));
	p->data = val;
	p->next = NULL;
	p->pre = NULL;
	return p;

}

删除双向链表
与单向链表的删除一样

void clear(Node *head)        // 删除单向链表
{
	if (head == NULL) return;
	// 循环遍历链表中每个节点, 当遍历不为空，就一直向后走
	for (Node *p = head, *q; p; p = q)   // p是当前节点
	{
		q = p->next;   // 先让q指向下一个节点
		free(p);       // 再销毁当前节点
	}
	return;
}
LAWKAWAI
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法-----链表
weixin_45932712的博客
08-05 319
线性表的链式存储结构链式存储∶用一组任意的存储单元存储线性表中的数据元素。用这种方法存储的线性表简称线性链表。 存储链表中结点的一组任意的存储单元可以是连续的，也可以是不连续的，甚至是零散分布在内存中的任意位置上的。 链表中结点的逻辑顺序和物理顺序不一定相同。 为了正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其直接后继结点的地址(或位置)，称为指针(pointer)或链(Ilink)，这两部分组成了链表中的结点结构，如图2-2所示。 链表是通过每个结点的指针域将线性表的n个结点按其逻..
数据结构与算法之链表
乞力马扎罗的雪CYF的博客
02-23 3066
链表的分类：（1）单链表头插法：只需要维护一个头结点即可，常用来模拟堆栈；尾插法：需要维护头结点和尾结点，常用来模拟队列。（2）双向链表双向遍历，可以用来保存网页的历史记录等；（3）循环链表经常出现在面试题中，判断链表是否有环。链表的删除方式一：维护两个指针，current（表示当前节点）和previous（表示当前节点的前一个节点）。当current遍历到要删除的元素时，执行previous->
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构的双链表算法
09-27
双链表是数据结构中的一种重要类型，它在计算机科学中有着广泛的应用。与单链表相比，双链表的特点在于每个节点不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针，这使得双向操作更加便捷。 在双链表...
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
数据结构与算法 实战代码
03-13
数据结构与算法是计算机科学的基础，对于任何编程领域，尤其是软件开发和系统设计，都有着至关重要的作用。在Java编程中，理解和熟练运用数据结构与算法能够显著提高程序的效率和可维护性。以下是对这些核心概念的...
数据结构与算法PPT
04-17
数据结构与算法是计算机科学的基础，它探讨了如何有效地存储和处理数据，以及设计和分析解决问题的算法。在本课程中，我们将深入学习这些概念，包括数据结构的逻辑和物理结构，抽象数据类型，以及算法的性能分析。 ...
算法与数据结构.zip
12-19
在实际编程中，这些数据结构的实现方式和效率往往与具体语言和应用场景有关。例如，链表操作在内存管理上比数组灵活，但访问速度较慢；字符串处理需要考虑到字符编码，如ASCII、Unicode等；二叉树在搜索和排序方面有...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 612
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
c语言（7.23）
fhgfyrsg的博客
07-23 509
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 787
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构：逻辑结构与物理结构
Weiki的博客
07-24 928
数据结构：逻辑结构与物理结构
数据结构之深入理解简单选择排序：原理、实现与示例（C，C++）
qq_35320456的博客
07-24 742
简单选择排序虽然在大数据量下效率不高，但它易于理解和实现，是理解排序算法基本思想的良好起点。在实际应用中，如果数据量较小或者对排序稳定性要求不高，选择排序可以作为一种简单有效的选择。
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 413
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构——单链表OJ题（下）
最新发布
2301_81888634的博客
07-25 636
链表既然包括单链表，就还有其他种类啦~敬请期待“双向链表”~
【数据结构】顺序表（c语言实现）（附源码）
2301_80955819的博客
07-24 827
顺序表的概念和结构，顺序表的分类，顺序表的功能实现
数据结构day3（双向链表操作）
weixin_66436813的博客
07-24 351
线性表的链式存储：解决了顺序存储的缺点，插入和删除。注意：用自己结构的指针一般就是 链表。DoubleLInk.h文件。DoubleLInk.c文件。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值