数据结构 十一道链表相关面试题,牛客 LeetCode,在线OJ题

第三题 : 链表的中间结点

======================================================================================

Leetcode 876:

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

示例 1：

输入：[1,2,3,4,5]

输出：此列表中的结点 3 (序列化形式：[3,4,5])

返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。

注意，我们返回了一个 ListNode 类型的对象 ans，这样：

ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

解题思路:

---

1.判断单链表是否为空,为空返回null

2.这题是求中间节点的,相当于求的是中间值,这时可以定义一个引用fast,和slow,让fast走两步,slow走一步.此时fast的速度是slow的两倍,时间不变,路程等于速度乘时间,路程也是两倍,相当于fast走到结尾的时候,slow就正好在中间位置.

3.fast走两步 fast=fast.next.next; slow走一步 slow=slow.next;

4.此时分为两种情况,一种为单数,一种为双数.单数的情况下,fast走到末尾,fast.next为空,双数时,fast走到末尾时,fast为空,所以此时要判断两种情况是否为空,为空循环结束

画图解析:

---

具体代码:

---

/**

• Definition for singly-linked list.

• public class ListNode {

• int val;
  

• ListNode next;
  

• ListNode() {}
  

• ListNode(int val) { this.val = val; }
  

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

• }

*/

class Solution {

public ListNode middleNode(ListNode head) {

if(head==null){

return null;

}

ListNode fast = head;

ListNode slow = head;

while(fast != null && fast.next != null) {

fast = fast.next.next;

slow = slow.next;

}

return slow;

}

}

第四题 : 链表中倒数第k个结点

=====================================================================================================

描述

输入一个链表，输出该链表中倒数第k个结点。

示例1

输入：

1,{1,2,3,4,5}

返回值：

{5}

解题思路:

---

1.首先判断链表是否为空,如果是空直接返回null

2.可以根据k的不同值可以判断出,k距离最后一个位置的距离为k-1

3.让fast先走k-1,slow不动,此时slow与fast的距离就是k与最后一个位置的距离,然后再让fast继续走,当fast为空的时候停止,此时slow所指向的位置就是倒数第k个节点的位置;

4.还要判断k所给值的合法性,当k小于0的时候不合法,当k＞链表长度不合法,如果要求链表长度就太麻烦了,可以在让fast先走k-1步的时候判断,fast.next是否为空为空就return null,就解决了求链表长度的问题.

画图解析:

---

 具体代码:

---

/*

public class ListNode {

int val;

ListNode next = null;

ListNode(int val) {

this.val = val;

}

}*/

public class Solution {

public ListNode FindKthToTail(ListNode head,int k) {

if(head==null){

return null;

}

if(k<0){

return null;

}

ListNode fast = head;

ListNode slow = head;

while( k-1 != 0){

if(fast.next==null){

return null;

}

fast = fast.next;

k–;

}

while(fast.next != null) {

fast = fast.next;

slow = slow.next;

}

return slow;

}

}

第五题 : 合并两个有序链表

======================================================================================

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

解题思路:

---

1.这题可以引用一个傀儡节点newHead,让newHead的值为-1,指向的地址为null;

2.让headA.val与headB.val进行比较

如果headA.val<headB.val 就让cur.next指向headA的地址,让headA指向下一个节点,cur就指向cur.next;

如果headA.val>=headB.val,就让cur.next指向headB的地址,让headB指向下一个节点,cur就指向cur.next;

3.循环此步骤,当headA为空或者headB为空的时候,结束循环

4.如果循环结束还有节点没连上,所以就让cur.next连上剩余的节点,判断是哪个head为空时,循环结束.此时看题目A末尾的数据在B之前,所以让判断headA的语句放在前面,因此也解决了链表为空的情况.

画图解析:

---

具体代码:

---

/**

• Definition for singly-linked list.

• public class ListNode {

• int val;
  

• ListNode next;
  

• ListNode() {}
  

• ListNode(int val) { this.val = val; }
  

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

• }

*/

class Solution {

public ListNode mergeTwoLists(ListNode headA, ListNode headB) {

ListNode newHead = new ListNode(-1);

ListNode cur = newHead;

while(headA != null && headB !=null) {

if(headA.val < headB.val){

cur.next = headA;

headA = headA.next;

cur = cur.next;

}else{

cur.next = headB;

headB = headB.next;

cur = cur.next;

}

}

if(headA != null){

cur.next = headA;

}

if(headB != null){

cur.next = headB;

}

return newHead.next;

}

}

第六题 : 链表分割

========================================================================================

描述

现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。

解题思路:

---

1.可以用两个链表分别来表示,小于x的 和 大于x的,再将2个链表连起来即可.

2. 两个链表分别用bs表示第一个链表的头,be表示第一个链表的尾,as表示第二个链表的头,ae表示第二个链表的尾.

3.引用一个cur指向head,比较cur.val与x的值,如果小于x的时候,bs,be就指向cur,如果大于x的时候,as,ae就指向cur.这一步只执行一次,可以通过判断bs是否为空,as是否为空来解决.

4.第一次的执行之后,就进入else,如果小于x的时候,be.next=cur,be=be.next;如果大于x的时候,ae.next=cur,ae=ae.next;

5.然后要连接2个链表;

有3种情况

①bs为空,返回as

②bs不为空,连接be,as,即be.next=as.next;

③当ae不为空,ae指向的地址可能不为空,所以要ae.next=null;

画图解析:

---

 具体代码:

---

import java.util.*;

/*

public class ListNode {

int val;

ListNode next = null;

ListNode(int val) {

this.val = val;

}

}*/

public class Partition {

public ListNode partition(ListNode head, int x) {

// write code here

ListNode bs = null;

ListNode be = null;

ListNode as = null;

ListNode ae = null;

ListNode cur = head;

while(cur != null) {

if(cur.val<x){

if(bs==null){

bs=cur;

be=cur;

}else {

be.next = cur;

be = be.next;

}

}

else{

if(as==null){

as=cur;

ae=cur;

}else{

ae.next = cur;

ae = ae.next;

}

}

cur = cur.next;

}

if(bs==null){

return as;

}

be.next = as;

if(as!=null){

ae.next = null;

}

return bs;

}

}

第七题 : 删除链表中重复的结点

====================================================================================================

描述

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表 1->2->3->3->4->4->5  处理后为 1->2->5

例如输入{1,2,3,3,4,4,5}时，对应的输出为{1,2,5}，对应的输入输出链表如下图所示：

解题思路:

---

1.引用一个傀儡节点当作头,把去重后的节点连接到傀儡节点上;

2.引用一个tmp指向傀儡节点,引用一个cur指向head;

3.当cur.val == cur.next.val的时候,要让cur=cur.next;当跳过这个节点之后,cur.val还是需要删掉的数据,所以要再cur=cur.next一次才能指向下一个节点,

4.重复的数可能有2个3个或者多个,可以用循环来解决

5.当cur.val != cur.next.val的时候,让tmp指向cur的地址,tmp就到tmp.next节点上,cur就移到下一个节点.

6.由代码看出来,在判断cur.next.val的时候,cur.next可能为空,所以要在判断时,加上cur.next != null

7.最后tmp节点所指向的地址可能不为空,所以在最后要让tmp.next=null;

画图解析:

---

代码实现:

---

/*

public class ListNode {

int val;

ListNode next = null;

ListNode(int val) {

this.val = val;

}

}

*/

public class Solution {

public ListNode deleteDuplication(ListNode head) {

ListNode newHead = new ListNode(-1);

ListNode tmp = newHead;

ListNode cur = head;

while(cur != null){

if(cur.next != null && cur.val == cur.next.val){

while(cur.next !=null && cur.val == cur.next.val){

cur = cur.next;

}

cur = cur.next;

}else{

tmp.next = cur;

tmp=tmp.next;

cur = cur.next;

}

}

tmp.next = null;

return newHead.next;

}

}

第八题 : 链表的回文结构

===============================================================================================

描述

对于一个链表，请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法，判断其是否为回文结构。

给定一个链表的头指针A，请返回一个bool值，代表其是否为回文结构。保证链表长度小于等于900。

解题思路:

---

1.判断链表是否为空

2.找中间节点 定义两个引用fast和slow,一个走两步,一个走一步

3.反转,定义一个引用cur等于slow的下一个节点的地址,然后让cur的下一个节点地址等于slow的地址,再让slow等于cur的节点,这时cur.next被修改了,所以在前面要定义一个curNext记录cur.next的地址,最后让cur=curNext.循环直到,cur=null结束

4.判断回文

①奇数 head=slow

②偶数 head.next=slow

画图解析:

---

代码实现:

---

import java.util.*;

/*

public class ListNode {

int val;

ListNode next = null;

ListNode(int val) {

this.val = val;

}

}*/

public class PalindromeList {

public boolean chkPalindrome(ListNode head) {

//链表为空

if(head == null) {

return true;

}

//1.找中间节点

ListNode fast = head;

ListNode slow = head;

while(fast != null && fast.next != null){

fast = fast.next.next;

slow = slow.next;

}

//2.反转

ListNode cur = slow.next;

while(cur!=null){

ListNode curNext = cur.next;

cur.next = slow;

slow = cur;

cur = curNext;

}

//判断回文

while(head != slow){

//偶数情况

if(head.next==slow){

return true;

}

if(head.val != slow.val){

return false;

}

head = head.next;

slow = slow.next;

}

return true;

}

}

第九题 : 相交链表

=======================================================================================

Leetcode 160:

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

解题思路:

---

1.首先分析两个链表相交的形状,只能为Y形状

2.再分析相交时,是val域相同还是next域相同

3.因为要保持原始结构,所以要定义两个引用pl,ps

4.pl始终指向最长的链表,ps始终指向最短的链表

5.先让pl指向headA,ps指向headB,求headA和headB链表的长度,lenA和lenB

6.求差值len=lenA-lenB,如果len<0的时候,让pl指向headB,ps指向headA,

7.如果len>=0的时候,pl和ps已经走到最后,所以要让他们重新指向开头

8.然后让pl走差值步,这样在同时走的时候next域才会相等时

8.最后让循环判断pl是否等于ps,相等时,返回pl即可

9.最开始判断链表是否为空,为空返回null;

画图解析:

---

代码实现:

---

/**

• Definition for singly-linked list.

• public class ListNode {

• int val;
  

• ListNode next;
  

• ListNode(int x) {
  

•     val = x;
  

•     next = null;
  

• }
  

• }

*/

public class Solution {

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

if(headA == null || headB == null) {

return null;

}

ListNode pl = headA;

ListNode ps = headB;

int lenA = 0;

int lenB = 0;

while(pl != null) {

lenA++;

pl = pl.next;

}

while(ps != null) {

lenB++;

ps = ps.next;

}

int len = lenA - lenB;//差值步

//len小于0的时候要让pl指向最长的,ps指向最短的

if(len < 0) {

pl = headB;

ps = headA;

len = lenB - lenA;

}else{

//让pl和ps重新指向头节点

pl = headA;

ps = headB;

}

//让pl走差值步

while(len != 0) {

pl = pl.next;

len–;

}

while(pl != ps) {

pl = pl.next;

ps = ps.next;

}

return pl;

}

}

第十题 : 环形链表

========================================================================

Leetcode 141:

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。

进阶：你能用 O(1)（即，常量）内存解决此问题吗？

解题思路:

---

1.先判断链表是否为空,为空返回null

2.定义两个引用,一个快一个慢,让fast走两步,slow走一步,这样总会相遇.

3.相遇了fast=slow的时候,就是换装链表

画图解析:

---

代码实现:

---

/**

• Definition for singly-linked list.

• class ListNode {

• int val;
  

• ListNode next;
  

• ListNode(int x) {
  

•     val = x;
  

•     next = null;
  

• }
  

• }

*/

public class Solution {

public boolean hasCycle(ListNode head) {

if(head == null){

return false;

}

ListNode fast = head;

ListNode slow = head;

while(fast != null && fast.next != null){

fast = fast.next.next;

slow = slow.next;

if(fast == slow) {

return true;

}

}

return false;

}

}

十一题 : 环形链表 II

=================================================================================

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

由于篇幅有限，这里就不一一罗列了，20道常见面试题（含答案）+21条MySQL性能调优经验小编已整理成Word文档或PDF文档

还有更多面试复习笔记分享如下

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

十一题 : 环形链表 II

=================================================================================

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-67gS4gGk-1713712350776)]

[外链图片转存中…(img-fOIDXTJ8-1713712350777)]

[外链图片转存中…(img-d0D8bOk5-1713712350777)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

由于篇幅有限，这里就不一一罗列了，20道常见面试题（含答案）+21条MySQL性能调优经验小编已整理成Word文档或PDF文档

[外链图片转存中…(img-iVE5j31H-1713712350778)]

还有更多面试复习笔记分享如下

[外链图片转存中…(img-kEsqqRHP-1713712350778)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！