链表

最新推荐文章于 2023-02-03 23:39:29 发布
最新推荐文章于 2023-02-03 23:39:29 发布
阅读量124 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40822303/article/details/89600584
版权

链表基础

打印一个自定义链表。

#include<iostream>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(NULL)
	{

	}
};
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	ListNode* head = &a;
	while (head)
	{
		cout << head->val << endl;
		head = head->next;
	}
	return 0;
}

链表逆序-1

已知链表的头结点，在不申请额外空间的前提下，将链表逆序。

#include<iostream>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(nullptr)
	{

	}
};
ListNode* reversedList(ListNode* head)
{
	ListNode* newList = nullptr;
	ListNode* nextNode = nullptr;
	while (head)
	{
		nextNode = head->next;
		head->next = newList;
		newList = head;
		head = nextNode;
	}
	return newList;
}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	ListNode* head = &a;
	cout << "原链表：" << endl;
	while (head)
	{
		cout  << head->val << endl;
		head = head->next;
	}
	head = reversedList(&a);
	cout << "逆序后的链表：" << endl;
	while (head)
	{
		cout  << head->val << endl;
		head = head->next;
	}
	return 0;
}

链表逆序-2

已知链表的头结点，在不申请额外空间的前提下，将链表从位置m到n逆序。

#include<iostream>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(nullptr)
	{

	}
};
ListNode* reversedAreaList(ListNode* head, int start, int end)
{
	int areaLength = end - start + 1;
	ListNode* newList = nullptr;
	ListNode* preListNode = nullptr;//逆序前的头节点前驱
	ListNode* result = head;
	while (head && --start)
	{
		preListNode = head;
		head = head->next;
	}
	ListNode* currListTail = head;
	while (head && areaLength)
	{
		ListNode* nextNode = head->next;
		head->next = newList;
		newList = head;
		head = nextNode;
		areaLength--;
	}
	currListTail->next = head;
	if (preListNode)
	{
		preListNode->next = newList;
	}
	else
	{
		result = newList;
	}
	return result;
}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	ListNode* head = &a;
	cout << "原链表：" << endl;
	while (head)
	{
		cout  << head->val << endl;
		head = head->next;
	}
	head = reversedAreaList(&a,2,4);
	cout << "逆序m-n后的链表：" << endl;
	while (head)
	{
		cout  << head->val << endl;
		head = head->next;
	}
	return 0;
}

链表交点

已知单链表A的头节点指针A，单链表B的头节点指针B，两个链表相交，求两链表交点的对应节点。

1-容器实现

#include<iostream>
using namespace std;
#include<set>
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(nullptr)
	{

	}
};
ListNode* intersectionNode(ListNode* headA, ListNode* headB)
{
	set<ListNode*> nodeset;
	while (headA)
	{
		nodeset.insert(headA);
		headA = headA->next;
	}
	while (headB)
	{
		if (nodeset.find(headB) != nodeset.end())
		{
			return headB;
		}
		headB = headB->next;
	}
	return nullptr;
}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	ListNode f(6);
	ListNode g(7);
	f.next = &g;
	g.next = &d;
	ListNode* head = intersectionNode(&a,&f);
	if (head)
	{
		cout << head->val << endl;
	}
	return 0;
}

2-遍历实现

#include<iostream>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(nullptr)
	{

	}
};
int getListLength(ListNode* head)
{
	int len = 0;
	while (head)
	{
		len++;
		head = head->next;
	}
	return len;
}
ListNode* advanceNode(int shortLen, int longLen, ListNode* head)
{
	int len = longLen - shortLen;
	while (head && len)
	{
		head = head->next;
		len--;
	}
	return head;
}
ListNode* intersectionNode(ListNode* headA, ListNode* headB)
{
	int lengthA = getListLength(headA);
	int lengthB = getListLength(headB);
	if (lengthA < lengthB)
	{
		headB = advanceNode(lengthA, lengthB, headB);
	}
	else
	{
		headA = advanceNode(lengthB, lengthA, headA);
	}
	while (headA && headB)
	{
		if (headA == headB)
		{
			return headB;
		}
		headA = headA->next;
		headB = headB->next;
	}
	return nullptr;
}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	ListNode f(6);
	ListNode g(7);
	f.next = &g;
	g.next = &d;
	ListNode* head = intersectionNode(&a,&f);
	if (head)
	{
		cout << head->val << endl;
	}
	return 0;
}

链表求环

已知链表可能存在环，若有环返回环起始节点，否则返回NULL;

1-容器实现

#include<iostream>
#include<set>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(nullptr)
	{

	}
};
ListNode* startNode(ListNode* head)
{
	set<ListNode*> nodeset;
	while (head)
	{
		if (nodeset.find(head) != nodeset.end())
		{
			return head;
		}
		nodeset.insert(head);
		head = head->next;
	}
	return NULL;
}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	e.next = &c;
	ListNode* head = startNode(&a);
	if (head)
	{
		cout << head->val << endl;
	}
	return 0;
}

2-遍历实现（快慢指针赛跑）

#include<iostream>
#include<set>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(nullptr)
	{

	}
};
ListNode* startNode(ListNode* head)
{
	ListNode* slow = head;
	ListNode* fast = head;
	ListNode* meet = NULL;
	while (fast)
	{
		slow = slow->next;
		fast = fast->next;
		if (!fast)
		{
			return NULL;
		}
		fast = fast->next;
		if (fast == slow)
		{
			meet = fast;
			break;
		}
	}
	if (!meet)
	{
		return NULL;
	}
	while (head && meet)
	{
		if (head == meet)
		{
			return head;
		}
		head = head->next;
		meet = meet->next;
	}
	return NULL;
}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	e.next = &c;
	ListNode* head = startNode(&a);
	if (head)
	{
		cout << head->val << endl;
	}
	return 0;
}

链表划分

已知链表头与数值指针val，要求将所有小于val的节点放在大于或等于val的节点前，且保持这些节点的原来的位置不变。

#include<iostream>
#include<set>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(nullptr)
	{

	}
};
ListNode* DivideListNode(ListNode* head,int val)
{
	ListNode lesshead(0);//设置两个临时头节点
	ListNode morehead(0);
	ListNode* lessptr = &lesshead;//对应指针指向这两个头节点
	ListNode* moreptr = &morehead;
	while (head)
	{
		if (head->val < val)//将小于val的节点值放在lessptr后
		{
			lessptr->next = head;
			lessptr = head;
		}
		else
		{
			moreptr->next = head;
			moreptr = head;
		}
		head = head->next;
	}
	lessptr->next = morehead.next;//将less链表尾与more链表头相连
	moreptr->next = NULL;
	return lesshead.next;
}
int main()
{
	ListNode a(6);
	ListNode b(8);
	ListNode c(3);
	ListNode d(1);
	ListNode e(2);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	ListNode* head = DivideListNode(&a,3);
	while(head)
	{
		cout << head->val << endl;
		head = head->next;
	}
	return 0;
}

链表的深度拷贝

已知一个复杂的链表，节点中有一个指向本链表任意某个节点的随机指针（可以为空），求该链表的深度拷贝。

#include<iostream>
#include<map>
#include<vector>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode* randomptr;//随机指针
	ListNode(int val) :val(val), next(nullptr),randomptr(nullptr)
	{

	}
};
ListNode* DivideListNode(ListNode* head)
{
	map<ListNode*, int> nodemap;
	vector<ListNode*> nodevec;
	ListNode* ptr = head;
	int i = 0;
	while (ptr)
	{
		nodevec.push_back(new ListNode(ptr->val));
		nodemap[ptr] = i;
		i++;
		ptr = ptr->next;
	}
	ptr = head;
	i = 0;
	nodevec.push_back(0);
	while (ptr)
	{
		nodevec[i]->next = nodevec[i + 1];
		if (ptr->randomptr)
		{
			int id = nodemap[ptr->randomptr];
			nodevec[i]->randomptr = nodevec[id];
		}
		ptr = ptr->next;
		i++;
	}
	return nodevec[0];

}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	a.next = &b;
	b.next = &c;
	c.next = &d;
	d.next = &e;
	a.randomptr = &c;
	b.randomptr = &b;
	c.randomptr = &b;
	e.randomptr = nullptr;
	ListNode* head = DivideListNode(&a);
	while(head)
	{
		cout << head->val;
		if(head->randomptr)
			cout << head->randomptr->val << endl;
		else
			cout << endl;
		head = head->next;
	}
	return 0;
}

链表合并-1

已知两个已排序的链表，头节点指针分别为headA和headB，现要求将这两个链表合并，合并后仍为有序的，并返回合并后的头节点。

#include<iostream>
#include<map>
#include<vector>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(nullptr)
	{

	}
};
ListNode* mergeList(ListNode* headA,ListNode* headB)
{
	ListNode tmpNode(0);
	ListNode* ptr = &tmpNode;
	while (headA && headB)
	{
		if (headA->val < headB->val)
		{
			ptr->next = headA;
			headA = headA->next;
		}
		else
		{
			ptr->next = headB;
			headB = headB->next;
		}
		ptr = ptr->next;
	}
	if (headA)
	{
		ptr->next = headA;
	}
	else
	{
		ptr->next = headB;
	}
	return tmpNode.next;
}
int main()
{
	ListNode a(1);
	ListNode b(2);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	ListNode f(6);
	a.next = &b;
	b.next = &c;
	d.next = &e;
	e.next = &f;

	ListNode* head = mergeList(&a,&d);
	while(head)
	{
		cout << head->val << endl;
		head = head->next;
	}
	return 0;
}

链表合并-2

已知k个已排序链表头节点指针，要求将这k个链表合并合并后仍为有序的，并返回合并后的该链表的头节点。

1-容器排序实现

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(nullptr)
	{

	}
};
bool cmp(const ListNode *a,const ListNode *b)
{
	return a->val < b->val;
}
ListNode* sortList(vector<ListNode*> vec)
{
	vector<ListNode*> nodevec;
	for (int i = 0; i < vec.size(); i++)
	{
		ListNode* head = vec[i];
		while (head)
		{
			nodevec.push_back(head);
			head = head->next;
		}
	}
	if (!nodevec.size())
	{
		return NULL;
	}
	sort(nodevec.begin(), nodevec.end(), cmp);
	nodevec[nodevec.size() - 1]->next = NULL;
	for (int i = 1; i < nodevec.size(); i++)
	{
		nodevec[i - 1]->next = nodevec[i];
	}
	return nodevec[0];
}
int main()
{
	ListNode a(6);
	ListNode b(5);
	ListNode c(4);
	ListNode d(3);
	ListNode e(2);
	ListNode f(1);
	a.next = &b;
	c.next = &d;
	e.next = &f;
	vector<ListNode*> vec;
	vec.push_back(&a);
	vec.push_back(&c);
	vec.push_back(&e);
	ListNode* head = sortList(vec);
	while(head)
	{
		cout << head->val << endl;
		head = head->next;
	}
	return 0;
}

2-分治递归实现

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct ListNode
{
	int val;//数据域
	ListNode* next;//指针域
	ListNode(int val) :val(val), next(nullptr)
	{

	}
};
ListNode* mergeTwoList(ListNode* headA, ListNode* headB)
{
	ListNode tmpNode(0);
	ListNode* ptr = &tmpNode;
	while (headA && headB)
	{
		if (headA->val < headB->val)
		{
			ptr->next = headA;
			headA = headA->next;
		}
		else
		{
			ptr->next = headB;
			headB = headB->next;
		}
		ptr = ptr->next;
	}
	if (headA)
	{
		ptr->next = headA;
	}
	else
	{
		ptr->next = headB;
	}
	return tmpNode.next;
}
ListNode* mergeKList(vector<ListNode*> vec)
{
	if (!vec.size())
	{
		return NULL;
	}
	if (vec.size() == 1)
	{
		return vec[0];
	}
	if (vec.size() == 2)
	{
		return mergeTwoList(vec[0], vec[1]);
	}
	int size = vec.size() / 2;
	vector<ListNode*> leftvec;
	vector<ListNode*> rightvec;
	for (int i = 0; i < size; i++)
	{
		leftvec.push_back(vec[i]);
	}
	for (int i = size; i < vec.size(); i++)
	{
		rightvec.push_back(vec[i]);
	}
	ListNode* headA = mergeKList(leftvec);
	ListNode* headB = mergeKList(rightvec);
	return mergeTwoList(headA, headB);
}
int main()
{
	ListNode a(1);
	ListNode b(7);
	ListNode c(3);
	ListNode d(4);
	ListNode e(5);
	ListNode f(8);
	a.next = &b;
	c.next = &d;
	e.next = &f;
	vector<ListNode*> vec;
	vec.push_back(&a);
	vec.push_back(&c);
	vec.push_back(&e);
	ListNode* head = mergeKList(vec);
	while(head)
	{
		cout << head->val << endl;
		head = head->next;
	}
	return 0;
}

 

夜深矣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表填空题（打印）1
08-08
【链表基础知识】 链表是一种线性数据结构，与数组不同，它不连续存储数据，而是通过节点间的指针连接。每个节点包含数据部分和一个指向下一个节点的指针。链表分为单向链表、双向链表和循环链表等类型。 1. **...
C语言实现静态链表
08-18
C语言实现静态链表 C语言实现静态链表是指在C语言中使用静态数组来实现链表结构的方法。静态链表是一种特殊的链表结构，它的内存是事先分配好的，链表的每个结点都是一个固定长度的结构体，而不是像动态链表那样...
链表力扣题解（上）
lihua777的博客
02-02 1508
单链无头无循环链表的基本： （1）链表的结构体： structListNode{ intval; structListNode*next; }; （2）定义指针指向： struct ListNode* n1=head 定义一个链表型的n1的指针指向头地址 （3）指向下一个地址 n1=n1->next; (4)指向该地址所存储的值 n1->val 1：反转链表 思路解析： 定义三个结构体型的指针，*n1，*n2，*...
c++链表数据结构
qq_45274913的博客
11-23 1151
有关链表的理解： 初始化时head表示第一个节点:head->next表示第二个结点，head->val表示第一个节点的值，head->next->val表示第二个节点的值 head,head->next都是指针型数据 题目一：判断是否为环形链表 思路：沿着链表进行遍历，将遍历元素存入哈希表，并且判断哈希表中该元素是否存在即可： class Solution { public: bool hasCycle(ListNode *head) { /
链表-算法总结
m0_60524373的博客
09-09 428
链表算法总结
删除链表中所有值为val的节点
ZBMS_的博客
10-29 844
题目描述： 问题：1->2->3->4 val=2 要求输出为：1->3->4 解题思路： 1： 遍历一遍链表，对比每个节点，删除值为val的节点； 2（需要注意的点）：一般来说遍历都是从头开始，但是在这种没有头节点的链表中势必要考虑若第一个节点就为所要删除的节点时该如何解决 if(!head) return head; while(hea...
数据结构——Leetcode&牛客网（链表）
weixin_45138295的博客
11-04 354
本文会逐渐更新LeetCode中的链表有关的题目
合并链表_合并链表_
10-03
合并链表是一个常见的数据结构问题，它涉及到对链表的操作，特别是涉及排序和连接操作。在本场景中，我们有两个非递减有序的链表A和B，目标是创建一个新的链表C，这个新链表C同样是非递减有序的。下面我们将详细探讨...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
算法训练营day3
最新发布
dgh_01的博客
02-03 71
链表 双指针
链表：链表简单介绍
——
02-22 1198
整理一下硬盘里关于链表的知识，温故而知新。链表是一种物理存储单元上非连续、非顺序的存储结构。其特点是有头尾结点，除头结点外，其它结点都只有一个前驱，除尾结点外，其它结点都只有一个后继。常见的链表有单向链表，双向链表，循环链表。单向链表的结构一般这样写typedef struct listnode { int val; struct listnode *next; }...
链表排序
思维缜密的博客
12-09 4724
下面的排序只针对无头结点的单链表，当然有头节点稍微改改就可以了 选择排序 选择排序就是每次选一个最小的，放到前面 为了方便操作，创造一个头结点 /** * Definition of singly-linked-list: * class ListNode { * public: * int val; * ListNode *next; * ListNode(int val) { * this->val = val; * t
【leetcode】链表的基本操作
Steve_Abelieve
04-29 2234
题目一： Reverse a singly linked list. 1->2->3->NULL NULL-<1-<2-<3 解法：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) :
【数据结构C++】链表（二）
qq_44747572的博客
12-19 1256
2. 链表 相交链表: https://leetcode-cn.com/problems/intersection-of-two-linked-lists/ 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。 如果两个链表不存在相交节点，返回 null 。 方法一：哈希集合 思路和算法 判断两个链表是否相交，可以使用哈希集合存储链表节点。 首先遍历链表headA，并将链表headA 中的每个节点加入哈希集合中。 然后遍历链表headB，
自动化框架之logbook
aa1384656303的博客
09-03 408
python:利用logbook模块管理日志 1. 模块安装(采用pip命令安装) 进入cmd命令,输入pip install logbook安装, 安装成功之后采用pip show logbook查看相关信息 2. logbook简介 http://logbook.readthedocs.io/en/stable/index.html 3. 用法说明 i...
牛客网算法学习笔记-链表
u012656267的博客
05-25 3866
对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。 给定一个链表的头结点head，同时给定阈值val，请返回一个链表，使小于等于它的结点在前，大于等于它的在后，保证结点值不重复。 测试样例： {1,4,2,5},3 {1,2,4,5} 单独建立两个头结点，并且建立两个尾结点，保证有头指针
删除链表——从LeetCode题海中总结常见套路
沉迷单车的追风少年
03-13 395
删除链表类的题目不难，全是套路，刷过就很简单 目录 删除链表结点套路总结： LeetCode203.移除链表元素 LeetCode面试题18.删除链表的节点 LeetCode237.删除链表中的结点 LeetCode83.删除排序链表中的重复元素 LeetCode82.删除排序链表中的重复元素II 面试题02.01.移除重复节点 删除链表结点套路总结： 虚拟新建虚拟头结点dum...
C语言实现链表操作
"链表-C语言" 链表是一种在计算机科学中广泛使用的数据结构，尤其在C语言中，它的实现是编程基础的重要组成部分。链表不同于数组，它不连续存储数据，而是通过节点间的指针链接来表示逻辑顺序。每个节点包含两部分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值