常见算法题分类总结之链表

已于 2022-04-26 09:10:04 修改
阅读量816 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java 算法 链表 leetcode
于 2022-04-10 10:24:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57469718/article/details/124073528
版权

相信我们大多数每每谈起算法题总会觉得很费脑子，很难，或者很多学弟学妹学完数据结构以后并不知道如何把学到的东西用到算法中去，但随着互联网公司的要求不断提高，想进一个好一点的互联网公司的技术岗，算法题都是必考的，只是难度的高低，我自己平时学也时长会觉得很难，但是在题目被做出来那一刻的喜悦和成就感总能让我忘记这些过程的艰辛。我觉得算法应该也是一个持续坚持的过程，也许我们现在不能手撕红黑树，但我们可以通过不断的学习，这些算法题像是以前的数学题，都有着一定的套路，我们先把理论知识学扎实了，再去分门别类地针对性的解决这一类一类的问题，对我而言这反正会是一场持久战，其实在不知不觉间这是我第二遍系统的学这些了，其实这些学习的日子真的过得很快，也很充实，时常会感谢曾经咬牙坚持的自己，即使自己很菜，也没有放弃，相信每一个牛逼的人都会有一段苦逼的日子，当然，我这还远远不够，只是个开始。

以下是我根据系统的课程和力扣官方题解以及力扣上各种大佬提供的方法自己总结出的一些相对简单易懂的方法来解决算法题，希望能够给大家提供一定的思路，然后自己比较再去选择便于自己理解并且能够手动实现的方法，这段时间我会将第一遍学习时的主要理论和第二遍重点学习的题目发出来，希望大家可以共同交流，共同进步，相信算法讨论起来能更加容易理解，深刻掌握。

当然，刚开始我的排版可能不太行，我慢慢修改，让大家看得更舒服。

我们先来看看什么是链表

⼀、链表介绍
 动态数组有明显的缺点：可能会造成内存的浪费
 是否可以⽤多少申请多少内存：链表可以
 链表是⼀种链式存储的线性表，所有元素的内存地址不⼀定是连续的

 Node节点

链表中的每⼀个内存块被称为节点Node，Node节点由两部分构成：
 存储数据(可以是任何类型)
 还需记录链上下⼀个节点的地址，即后继指针next，⽤来存储下⼀个节点的Node对象


链表的优缺点
数组的插入、删除操作时，为了保持内存数据的连续性，需要做大量的数据搬移， 所以时间复杂度是 O(n) 在链表中插入和删除一个数据是非常快速的，我们只需要考虑相邻结点的指针改 变，所以对应的时间复杂度是 O(1)。

 二、常用链表
最常见的链表结构，它们分别是：单链表、双向链表和循环链表。

1.单链表
1）每个节点只包含一个指针，即后继指针。
2）单链表有两个特殊的节点，即首节点和尾节点。用首节点地址表示整条链表，尾节点的后 继指针指向空地址null。
3）性能特点：插入和删除节点的时间复杂度为O（1），查找的时间复杂度为O(n)。

2.循环链表
1）除了尾节点的后继指针指向首节点的地址外均与单链表一致。 2）适用于存储有循环特点的数据，比如约瑟夫问题。

3.双向链表
1）节点除了存储数据外，还有两个指针分别指向前一个节点地址（前驱指针prev）和下一个 节点地址（后继指针next）。
2）首节点的前驱指针prev和尾节点的后继指针均指向空地址。
3）性能特点： 和单链表相比，存储相同的数据，需要消耗更多的存储空间。 插入、删除操作比单链表效率更高O(1)级别。

以删除操作为例，删除操作分为2种情况：给定数据值删除对应节点和给定节点地址删除节 点。
第一种情况：单链表和双向链表都需要从头到尾进行遍历从而找到对应节点进行删除，时 间复杂度为O(n)。
第二种情况：要进行删除操作必须找到前驱节点，单链表需要从头到尾进行遍历直到p>next = q，时间复杂度为O(n)，而双向链表可以直接找到前驱节点，时间复杂度为 O(1)。
对于一个有序链表，双向链表的按值查询效率要比单链表高一些。因为我们可以记录上次 查找的位置p，每一次查询时，根据要查找的值与p的大小关系，决定是往前还是往后查 找，所以平均只需要查找一半的数据。

4.双向循环链表
 在双向循环链表中，可见的不只有头指针head，还有尾节点end。这是和单链表的 区别。
 双向循环链表的头指针head的前一个节点指向end，尾节点end的后一个节点指向 head。

class ListNode {
	int val;
	ListNode next;
	ListNode() {}
	ListNode(int val) { this.val = val; }
	ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}

//环形链表
public class Num141 {
	public boolean hasCycle(ListNode head) {
		Set<ListNode> set = new HashSet<>();
		ListNode p = head;
		while(p != null) {
			if(!set.add(p)) {
				return true;
			}
			p = p.next;
		}
		return false;
	}
	//进阶 用O(1)内存 —— 快慢指针
	public boolean hasCycle2(ListNode head) {
		if(head == null) return false;
		ListNode pre = head, cur = head;
		//快指针为空，表示遍历完了，能从这个循环走出来，说明无环
		while(cur != null && cur.next != null ) {
			pre = pre.next;
			cur = cur.next.next;
			if(pre == cur) return true;
		}
		return false;
	}
}

//环形链表2
public class Num142 {
	public ListNode detectCycle(ListNode head) {
		ListNode p = head;
		Set<ListNode> set = new HashSet<>();
		while(p != null) {
			if(!set.add(p)) {
				return p;
			}
			p = p.next;
		}
		return null;
	}
	//进阶 使用O(1)空间 —— 快慢指针
	public ListNode detectCycle2(ListNode head) {
		if(head == null) return null;
		ListNode pre = head, cur = head;
		while(cur != null && cur.next != null) {
			pre = pre.next;
			cur = cur.next.next;
			if(pre == cur) {//相遇了，找到入环点
				cur = head; //相对运动
				while(cur != pre) {
					cur = cur.next;
					pre = pre.next;
				}
				//走出循环即两指针相遇，肯定为环的入口
				return cur;
			}
		}
		//走的是非环形列表
		return null;
	}
}


//快乐数
public class Num202 {
	public boolean isHappy(int n) {
		int pre = n;
		int cur = getNext(n);
		while(pre != cur && cur != 1) {
			pre = getNext(pre);
			cur = getNext(getNext(cur));
		}
		return cur == 1;
	}
	
	private int getNext(int n) {
		int res = 0;
		while(n != 0) {
			int d = n % 10;
			res += d * d;
			n /= 10;
		}
		return res;
	}
}

//反转链表
public class Num206 {
	public ListNode reverseList(ListNode head) {
		//pre是反转后链表的头节点 cur是原链表的头节点
		ListNode pre = null, cur = head, next = null;
		while(cur != null) {
			next = cur.next;
			cur.next = pre;
			pre = cur;
			cur = next;
		}
		return pre;
	}
	//递归方法
	public ListNode reverseList2(ListNode head) {
		if(head == null || head.next == null) {
			return head;
		}
		ListNode newNode = reverseList2(head.next);
		//后面指向前面
		head.next.next = head;
		//取消指向后面的线
		head.next = null;
		return newNode;
	}
}

//反转链表2
public class Num92 {
	//核心思路： cur后面的节点插入到pre后面的节点
	public ListNode reverseBetween(ListNode head, int left, int right) {
		//有时候连头节点一起反转，所以需要一个虚拟头节点
		ListNode hair = new ListNode(-1, head);
		ListNode pre = hair, cur = head;
		//根据left确定pre和head的关系
		//将cur放到left位置上
		for(int i = 0; i < left - 1; i++) {
			cur = cur.next;
			pre = pre.next;
		}
		//使用头插法
		for(int i = 0; i < right - left; i++) {
			//用临时变量记录要删除的节点
			ListNode temp = cur.next;
			//删除操作（单向链表无法自我删除，必须知道该节点和前一个节点）
			cur.next = cur.next.next;
			//temp指向pre的下一个节点
			temp.next = pre.next;
			//pre再指向temp
			pre.next = temp;
		}
		//因为hair永远连着头节点
		//不能直接返回头节点的原因：头节点可能也一起反转了
		return hair.next;
	}
}

//k个一组翻转链表（hard）
public class Num25 {
	/**
	 * 1.找到k个要翻转的节点
	 * 2.进行翻转 返回翻转后的头节点和尾节点
	 * 3.对下一轮k个节点进行操作
	 * 4.将每轮的k个节点连接
	 * 法一报空指针异常
	 */
	public ListNode reverseKGroup(ListNode head, int k) {
		ListNode hair = new ListNode(-1, head);
		ListNode pre = hair;
		ListNode tail = null;
		while(head != null) {
			tail = pre;
			for(int i = 0; i < k; i++) {
				tail = tail.next;
				if(tail == null) {//说明末尾节点已经不足k个了
					return hair.next;
				}
			}
			ListNode[] revers = reverse(head, tail);
			//头节点和尾节点归位
			head = revers[0];
			tail = revers[1];

			pre.next = head;
			//pre继续移动，走向下一个要翻转的链表头部（也就是正在翻转链表的尾部）
			pre = tail;
			//head指针也移动
			head = pre.next;
		}
		return hair.next;
	}
	
	public ListNode[] reverse(ListNode head, ListNode tail) {
		//pre指向tail的下一个节点 方便和后续节点连接
		ListNode pre = tail.next, cur = head, next = null;
		//进循环说明链表还没翻转完成
		while(pre != tail) {
			next = cur.next;
			cur.next = pre;
			//后移继续迭代
			pre = cur;
			cur = next;
		}
		return new ListNode[]{tail, head};
	}
	
	//递归解法
	public ListNode reverseKGroup2(ListNode head, int k) {
		if(head == null || head.next == null) {
			return head;
		}
		ListNode firstHead = head;
		ListNode firstTail = head;
		for(int i = 0; i < k - 1; i++) {
			//把firstTail移动到要翻转节点的尾部
			firstTail = firstTail.next;
			if(firstTail == null) {
				//为null说明下一段要翻转的链表长度不够k 直接返回原链表
				return firstHead;	
			}
		}
		ListNode secondHead = firstTail.next;
		//把链表分段
		firstTail.next = null;
		reverse2(firstHead);
		//翻转之后头尾变了
		firstHead.next = reverseKGroup2(secondHead, k);
		return firstTail;
	}
	//递归来解决
	private ListNode reverse2(ListNode head) {
		if(head == null || head.next == null) {
			return head;
		}
		ListNode next = head.next;
		ListNode newHead = reverse2(next);
		next.next = head;
		head.next = null;
		return newHead;
	}
}

//旋转链表
public class Num61 {
	/* 核心思路：
	 * 当k小于链表长度时
	 * 链表先成环，然后找到倒数第k个节点和倒数第k+1个节点 断开
	 * 再返回倒数第k个节点
	 * 当k大于链表长度时 有重复操作 取余减少操作*/
	public ListNode rotateRight(ListNode head, int k) {
		if(head == null || head.next == null) return head;
		//初始化链表长度为1
		int len = 1;
		ListNode oldTail = head;
		while(oldTail.next != null) {
			oldTail = oldTail.next;
			//记录链表长度
			len++;
		}
		//成环
		oldTail.next = head;
		ListNode newTail = head;
		//当k大于链表长度时 取余来除掉多余步数
		for(int i = 0; i < len - k % len - 1;i++) {
			//newTail找的就是倒数k+1个节点
			newTail = newTail.next;
		}
		//新链表头部
		ListNode newHead = newTail.next;
		//将头尾断开
		newTail.next = null;
		return newHead;
	}
}

public class Num24 {
	public ListNode swapPairs(ListNode head) {
		if(head == null || head.next == null) return head;
		ListNode hair = new ListNode(-1, head);
		ListNode pre = hair;
		while(pre.next != null && pre.next.next != null) {
			ListNode one = pre.next;
			ListNode two = pre.next.next;
			//翻转
			one.next = two.next;
			two.next = one;
			pre.next = two;
			//继续后移迭代，因为此时one是下一链表头节点的前驱节点
			pre = one;
		}
		return hair.next;
	}
	
//	private ListNode reverse(ListNode head) {
//		if(head == null || head.next == null) return head;
//		ListNode newNode = reverse(head.next);
//		head.next.next = head;
//		head.next = null;
//		return newNode;
//	}
	//递归解法
	public ListNode swapPairs2(ListNode head) {
		if(head == null || head.next == null) return head;
		ListNode newHead = head.next;
		head.next = swapPairs2(newHead.next);
		newHead.next = head;
		head = newHead.next;
		return newHead;
	}
}

//删除链表的倒数第N个节点
public class Num19 {
	public ListNode removeNthFromEnd(ListNode head, int n) {
		//有这个就错了
//		if(head == null || head.next == null) return head;
		ListNode hair = new ListNode(-1, head);
		//p先走n步，然后q和p同时走，两者相差n步，q指的就是倒数n+1那个节点
		ListNode p = head, q = hair;
		for(int i = 0; i < n ;i++) {//或者while(n-- > 0)
			p = p.next;
		}
		while(p != null) {
			p = p.next;
			q = q.next;
		}
		//删除节点
		q.next = q.next.next;
		//可以省略
//		q.next.next = null;
		return hair.next;
	}
}

//删除排序链表中的重复元素
public class Num83 {
	public ListNode deleteDuplicates(ListNode head) {
		//没有也给过了
//		if(head == null) return null;
		ListNode cur = head;
		while(cur != null && cur.next != null) {
			if(cur.next.val == cur.val) {
				cur.next = cur.next.next;
			} else {
				cur = cur.next;
			}
		}
		return head;
	} 
}

//删除排序链表中的重复元素2
public class Num82 {
	//双指针
	public ListNode deleteDuplicates(ListNode head) {
		if(head == null) return null;
		ListNode hair = new ListNode(-1, head);
		ListNode pre = hair, cur = head;
		while(cur != null && cur.next != null) {
			if(cur.next.val != cur.val) {
				pre = pre.next;
				cur = cur.next;
			}else {
				//下一个是重复的值
				while(cur != null && cur.next != null &&
						cur.val == cur.next.val) {
					cur = cur.next;
				}
				pre.next = cur.next;
				cur = cur.next;
			}
		}
		return hair.next;
	}
}

慢慢敲吧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——常见链表算法题
secretboys的博客
08-18 718
本文介绍常见的有关链表的算法题，值得一提的是，该代码无需在力扣上，可在本地运行成功。1.反转链表2.移除链表中的重复节点3.查找链表中的中间节点4.找到链表中的倒数第k个节点5.合并两个升序链表，并同样按照升序排列6.判断是否为环形链表7.查找两链表的交点，相交链表8.判断是否为回文链表（空链表和单节点链表也算）......
关于链表的常见算法题(一)
weixin_34186931的博客
06-16 1088
关于链表的常见算法题(二) 关于链表的常见算法题(一) 链表一直是面试最喜欢考的数据结构，灵活而又多变，代码往往也不是特别长。 从尾到头打印链表 输入一个链表的头节点，从尾到头反过来打印出每个节点的值 例如链表为1->2->3，打印出3 2 1 有三种思路可以参考： 栈：栈天然是先进后出的，在遍历链表时，把值按顺序放入栈中，最后出栈就是逆序了。 既然想到了栈，那么递归天然是一个栈...
链表类算法题
qq_33690342的博客
02-19 589
1、反转链表leetcode 206： // ListNode Definition for singly-linked list. type ListNode struct { Val int Next *ListNode } func reverseList(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } var prev *Li
链表常见算法题总结
Linias的博客
04-05 444
https://github.com/lxsnwu/Algorithm/tree/master/%E9%93%BE%E8%A1%A8
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
Java实现链表的常见操作算法详解
08-25
主要介绍了Java实现链表的常见操作算法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
常见：算法面试题总结1
08-08
2.如果需要求出俩个链表相交的第一个节点列?第8题此贴选一些 比较怪的题，，由于其中题目本身与算法关系不大，仅考考思维。特此并作一题。1.有两个房间，一间房里有
链表类常见算法题总结
sshhsun的专栏
07-21 336
链表类常见算法题目总结
链表常考算法题
qq_43103261的博客
09-25 648
1.链表的倒数第K个结点 问题描述： 输入一个链表，输出该链表中倒数第k个结点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾结点是倒数第1个结点。例如一个链表有6个结点，从头结点开始它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个结点是值为4的结点,需要保证时间复杂度。 算法思路： 设置两个指针p1,p2，从头到尾开始出发，一个指针先出发k个节点，然后第二个指针再进行出发，当第一个指针到达链表的节点的时候，则第二个指针表示的位置就是链表的倒数第k个节点的位置。 代码如下：
数据结构 链表常见算法问题(二)
qq_43128902的博客
10-09 341
数据结构，线性表，链表常见算法 算法和问题来自于试卷，辅导书，以及网络。 // 数据结构 typedef struct LNode{ int data; struct Lnode *next; }LNode,*LinkList; 算法2.2.11 假设有两个单链表，其中元素递增排列，编写算法将这两个链表归并为一个按元素值递减次序排列的单链表，要求利用原来两个单链表的节点存放归并后的节点。 分析：假设有A,B两个链表，均带有头节点，将他们的节点依次取下比较，对较小的采用头插法即可。 void
链表经典算法题
Frank的博客
10-03 1664
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
两个链表相交的一系列问题
OY_palada
07-26 364
程序员代码面试指南（左程云）读书笔记  第二章 两个链表相交的一系列问题   在本题中单链表可能有环，也可能没有环。给定连个单链表的头节点，head1和head2,这连个链表可能相交，也可能不相交。 请实现一个函数，如果两个链表相交，请返回相交的第一个节点，如果不相交，返回null; 要求：      如果链表1的长度为N,链表2的长的为W,时间复杂度问O（N+W）,额外空间复
链表经典算法题目
qq_42575907的博客
11-27 469
思路：利用一个map，把原链表的Node当作key,新复制的Node当作value,然后利用Map的映射关系把原链表的Node的next和random复制到新复制的Node中。思路： 在Node后面串一个复制的Node，然后给复制的Node的random赋值，把复制的Node从老链表里拆出来。思路：使用快慢指针，找到中间的节点，然后从中间节点反转链表，头尾同时遍历比较，最后再把反转的链表恢复过来。对于这种比较简单的题目，想要出彩，就要考虑优化的点，考虑空间复杂度，压缩空间。函数，复制一个复杂链表。
链表相关经典算法题总结(C语言+数据结构)
weixin_49312527的博客
12-12 1692
我们针对链表中最经典的几道算法题做讲解: 1.求两个链表的公共节点. 2.判断链表是否有环. 3.给定一个链表,判断是否有环,有返回入环的第一个节点,无返回空.(在第二题上的加强版). 4.给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。要求返回这个链表的深度拷贝. 5.对链表进行插入排序. 6.在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针. 一.详细讲解 1.求两个链表的公共节点.(如图)
链表的经典算法题
Alaskan_Husky的博客
11-19 116
链表是常见的数据结构之一，有许多经典的算法问题涉及到链表。将链表反转，即将原链表的每个节点的指针方向反向。判断链表中是否存在环，即链表是否形成了一个闭环。将两个有序链表合并成一个有序链表。删除有序链表中的重复元素，使每个元素只出现一次。删除链表中倒数第N个节点。找到链表的中间节点，如果有两个中间节点，返回第二个。交换链表中相邻的节点，返回新的头节点。判断链表是否是回文结构，即链表从前往后和从后往前读是相同的。找到环形链表的起始节点。找到两个链表相交的起始节点。
02.链表经典算法题
qq_45385121的博客
12-01 470
链表经典算法题 1.快慢指针 1)输入链表头节点，奇数长度返回中点，偶数长度返回上中点 class Node{ public int value; public Node next; public Node(int value) { this.value = value; next = null; } public static Node midOrUpMidNode(Node head) { if (head == null || head.next == nu
链表基础题大全（三）：奇偶链表和旋转链表
冷血之心的博客
04-22 504
这段时间完成了职业生涯第一次跳槽，对算法题目有了一个更深的认识和理解，这里将链表常见的面试题目以及解法补充完善。 链表基础题大全（一） 链表基础题大全（二） 链表基础题大全（三） 链表基础题大全（四） 在前面两个小节的介绍中，我们主要介绍了基础的链表题目，主要是利用了双指针的思想。本篇博文，我们来看两道经典的题目：奇偶链表和旋转链表。 奇偶链表 给定一个单链表，把所有的奇数节点和偶数节点分别排...
数据结构与算法约瑟夫环之循环链表
最新发布
12-03
循环链表是一种特殊的链表，它的最后一个节点指向头节点，形成一个环。约瑟夫环问题是一个经典的问题，它的描述是：n个人围成一圈，从第k个人开始报数，报到m的人出圈，然后从出圈的下一个人开始重新报数，直到所有人出圈。这个问题可以使用循环链表来解决。 具体实现思路如下1. 创建一个单向循环链表，链表中每个节点存储一个人的密码和顺序。 2. 从第k个人开始，依次遍历链表，直到找到第m个人，将该节点从链表中删除。 3. 重复步骤2，直到链表中只剩下一个节点，返回该节点的顺序即可。 以下是Python代码实现： ```python class Node: def __init__(self, password, order): self.password = password self.order = order self.next = None def josephus(n, k, m): # 创建循环链表 head = Node(0, 0) cur = head for i in range(1, n+1): cur.next = Node(i, i) cur = cur.next cur.next = head.next # 从第k个人开始报数，直到找到第m个人并删除 cur = head.next while cur.next != cur: for i in range(k-1): cur = cur.next for i in range(m-1): cur = cur.next print("出列的人的顺序为：", cur.next.order) cur.next = cur.next.next # 返回最后一个节点的顺序 return cur.order # 测试 n = 7 k = 3 m = 4 print("最后一个出列的人的顺序为：", josephus(n, k, m)) ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值