大学生因疫情被封宿舍，无聊？那就刷几道链表的算法题解解闷儿---Java实现
Posted Java猿~
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了大学生因疫情被封宿舍，无聊？那就刷几道链表的算法题解解闷儿---Java实现相关的知识，希望对你有一定的参考价值。
前言
🍃大家好！！！我是Java猿~
🍄因为疫情原因被封宿舍，这样也好，不乱跑，不给社会添乱。
🌸因为在宿舍无事可干，但是也不能落下学习，所以刷几道链表的OJ题来巩固之前所学的，这里分享一下解题方法，希望大家相互学习，欢迎回访哟！！！
🌿新的一年，祝大家虎年快乐！！！🐅🦁🐅
💪最后也希望疫情快点结束，加油陕西！加油长安！！！
目录
LeetCode 203 移除链表元素
题目链接：移除链表元素
题目：给一个链表和一个整数，删除链表中所有值为该整数的节点，并将删除后的链表返回。
示例：
题目解析：删除链表中所有节点元素等于一个整数的节点，返回删除后的链表的头节点。
🤔思路：遍历链表与给定值比较，如果节点的值与给定值相等就删除该节点，链表节点的删除需要标记删除节点的前一个节点，具体步骤如下：
1. 首先进行链表判空，如果链表为空，则将空链表返回就行
2. 给两个标记，cur标记依次遍历的节点，pre标记cur的前一个结点
3. 判断要删除的结点是否为头节点，如果为头节点就要更新头节点，因为题目要求返回删除后链表的头节点，判断头节点的方法是pre为null
4. 如果不是头节点就正常删除即可
👁🗨参考代码：
class Solution
public ListNode removeElements(ListNode head, int val)
//判空
if(head == null)
return head;
ListNode cur = head;
ListNode pre = null;
while(cur != null)
if(cur.val == val)
if(pre == null) //删除节点为头节点
head = cur.next; //更新头节点
cur = head;
else
pre.next = cur.next;
cur = pre.next;
else //如果当前节点不是要删除的节点，依次遍历
pre = cur;
cur = cur.next;
return head;
LeetCode 876 链表的中间节点
题目链接：链表的中间节点
题目：给一个头节点为head的非空单链表，返回链表的中间节点，如果中间节点有两个，则返回第二个中间节点。
题目解析：如果链表有奇数个节点，则返回中间的节点，如果有链表有偶数个节点，则返回中间两个靠后的节点，画图说明：
🤔思路：快慢指针法：一个快指针fast，一个慢指针slow，两个指针同时依次遍历链表当快指针走到末尾的时候，慢指针刚好走到中间位置，画图说明：
具体步骤：
1. fast快指针与slow慢指针依次遍历
2. 遍历的条件：fast != null && fast.next != null
3. 最后当遍历条件不满足的时候，返回slow
👁🗨参考代码：
class Solution
public ListNode middleNode(ListNode head)
ListNode fast = head;
ListNode slow = head;
while(fast != null && fast.next != null)
fast = fast.next.next;
slow = slow.next;
return slow;
剑指Offer 22 链表中倒数第k个节点
题目链接：链表中倒数第k个节点
题目：输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
示例：
🤔思路：这一提供一个巧妙方法：给两个指针fast，slow，fast先走，slow后走，两个指针都是从链表头开始遍历，当fast走完k个节点后，slow在开始从头部开始走，而fast继续从当前节点往后走，当fast走到null的时候，slow对应的节点即为要返回的节点。具体步骤如下：
1. fast开始走完k个节点
2. slow再与fast同时开始往后每次走一步
3. 当fast走到链表末尾，slow即为要返回节点
👁🗨参考代码：
class Solution
public ListNode getKthFromEnd(ListNode head, int k)
ListNode fast = head;
ListNode slow = head;
while(k > 0)
fast = fast.next;
k--;
while(fast != null)
fast = fast.next;
slow = slow.next;
return slow;
LeetCode 21 合并两个有序链表
题目链接：合并两个有序链表
题目：将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。示例：
题目解析：给两个升序链表，将这两个升序链表合并为一个升序链表
🤔思路：对于本题，我们可以创建一个新的链表，让两个链表的元素依次比较，哪个元素小，就链接在新链表中，依次循环，当某一个链表的节点都已经链接新的链表中，就把另一个链表剩余的节点直接链接在新链表中。具体步骤如下：
1. 先new一个新的链表
2. 将两个链表的元素依次遍历比较
3. 将元素小的节点插入新的链表中，继续比较
4. 当有一条链表的元素全部插入新的链表中，就把另一条链表剩余的部分链接到新的链表的末尾
👁🗨参考代码：
class Solution
public ListNode mergeTwoLists(ListNode list1, ListNode list2)
ListNode list3 = new ListNode(0);
ListNode cur = list3;
while(list1 != null && list2 != null)
if(list1.val < list2.val)
cur.next = list1;
cur = cur.next;
list1 = list1.next;
else
cur.next = list2;
cur = cur.next;
list2 = list2.next;
if(list1 != null)
cur.next = list1;
if(list2 != null)
cur.next = list2;
return list3.next;
Leetcode 面试题 02.04. 分割链表
题目链接：分割链表
题目：给你一个链表的头节点head和一个特定值x，请你对链表进行分隔，使得所有小于x 的节点都出现在大于等于x 的节点之前。示例：
题目解析：给一条链表和一个特定的值，将链表中的值与给定的值比较，将小于给定值的节点排在链表的前面，其余的就按照开始的顺序排在后面。
🤔思路：我们可以创建两条链表，将小于给定值的节点插入第一条链表中，将剩余节点插入第二条链表中，最后将这两条链表进行链接即可。具体步骤如下：
1. 对链表进行判空，如果链表为空，将空链表返回即可
2. new两条新的链表
3. 遍历链表，将小于给定值的节点插入第一条链表，剩余节点插入第二条链表
4. 链接两条链表，第一条链表的尾链接第二条链表的头
5. 第二条链表的尾部指向空即可
👁🗨参考代码：
class Solution
public ListNode partition(ListNode head, int x)
if(head == null)
return head;
ListNode headL = new ListNode(0);
ListNode curL = headL;
ListNode headR = new ListNode(0);
ListNode curR = headR;
ListNode cur = head;
while(cur != null)
if(cur.val < x)
curL.next = cur;
curL = cur;
cur = cur.next;
else
curR.next = cur;
curR = cur;
cur = cur.next;
curL.next = headR.next;
curR.next = null;
return headL.next;
LeetCode 234 回文链表
题目链接：回文链表
题目：给一条链表，如果链表满足回文结构返回true，否则返回false
题目解析：所谓回文结构就是正着与反着是一样的比如：12321，123321，这样的结构就是回文结构。
🤔思路1：我们可以将链表的结点元素保存在数组中，然后判断这个数组是否回文，具体步骤如下：
1. new一个ArrayList，用于保存链表结点元素
2. 遍历链表，将链表结点元素保存在List中
3. 从List头部拿一个元素，尾部拿一个元素进行比较，如果相同进行下一轮比较，如果不相同返回false
4. 当链表遍历完后，都相同的话返回true
👁🗨参考代码：
class Solution
public boolean isPalindrome(ListNode head)
//将值复制到数组中，判断数组是否回文
List<Integer> list = new ArrayList<>();
ListNode cur = head;
while(cur != null)
list.add(cur.val);
cur = cur.next;
int left = 0;
int right = list.size()-1;
while(left < right)
if(list.get(left) == list.get(right))
left++;
right--;
else
return false;
return true;
🤔思路2：我们可以将链表进行分割，然后将后半部分链表进行逆置，再将逆置后的部分与前半部分依次比较，如果结点的值都相同则为回文，否则不是回文结构。具体步骤如下：
1. 分割链表，上一题讲过，可以参考上一题2. 逆置链表，这个前面也讲过，附上链接，不会的可以点击链接学习，LeetCode206---反转链表（Java实现，有图解）_轻盈照溪水的博客-CSDN博客
3. 进行比较
注意：这种思路涉及到链表的分割与逆置，故当作重点题进行学习
👁🗨参考代码：
class Solution
public ListNode getMid(ListNode head)
ListNode fast = head;
ListNode slow = head;
ListNode pre = null;
while(fast != null && fast.next != null)
fast = fast.next.next;
pre = slow;
slow = slow.next;
if(fast != null)
return slow;
else
return pre;
public ListNode reverse(ListNode head)
ListNode cur = head;
ListNode next = null;
ListNode pre = null;
while(cur != null)
next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
return pre;
public boolean isPalindrome(ListNode head)
ListNode mid = getMid(head);
ListNode B = mid.next;
B = reverse(B);
ListNode curB = B;
ListNode curA = head;
while(curB != null)
if(curA.val != curB.val)
return false;
curA = curA.next;
curB = curB.next;
return true;
LeetCode 160 相交链表
题目链接：相交链表
题目：给两条链表的头节点，返回两条链表的起始节点，如果不相交，返回null
题目解析：有两条链表，链表可能会相交，如果相交返回相交的起始节点，如果不相交返回null
🤔思路：首先进行判断链表是否相交，判断依据：如果两条链表相交，则两条链表的尾节点一定是相同的。在相交前，有可能两条链表一样长，也有可能不一样长，对应如下情形：
对于左边的这种情形：直接遍历求第一个相等的节点即可
对于右边的这种情形：可以先统计两条链表的长度，哪条长，就先走超出的长度，走完后，两条链表在同时遍历，这样就形成了左边的情形，即很快可以找到相交节点
具体步骤：
1. 进行判空，如果有一条链表为空，肯定不相交，直接返回null
2. 统计两条链表节点的个数，将两条链表对应的节点个数做差
3. 统计完个数，两条链表都到末尾，判断末尾节点是否相同，若不同说明不存在交点，返回null
4. 如果差值大于0，说明第一条链表长，先走差值个长度
5. 如果差值小于0，说明第二条链表长，先走差值个长度
6. 两条链表再依次遍历，找相同的节点然后返回
👁🗨参考代码：
public class Solution
public ListNode getIntersectionNode(ListNode headA, ListNode headB)
if(headA == null || headB == null)
return null;
ListNode curA = headA;
int sizeA = 1;
while(curA != null)
sizeA++;
curA = curA.next;
ListNode curB = headB;
int sizeB = 1;
while(curB != null)
sizeB++;
curB = curB.next;
if(curA != curB)
return null;
curA = headA;
curB = headB;
int alm = sizeA - sizeB;
if(alm >= 0)
while(alm > 0)
curA = curA.next;
alm--;
else
while(alm < 0)
curB = curB.next;
alm++;
while(curA != curB)
curA = curA.next;
curB = curB.next;
return curA;
以上是关于大学生因疫情被封宿舍，无聊？那就刷几道链表的算法题解解闷儿---Java实现的主要内容，如果未能解决你的问题，请参考以下文章