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

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

}*/

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 仅仅是用于标识环的情况，并不会作为参数传递到函数中。

说明：不允许修改给定的链表。

进阶：你是否可以使用 O(1) 空间解决此题？

示例 1：

解题思路:

---

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

2.定义两个引用fast和slow,fast速度是slow的两倍,他们相遇时,就是相遇点

3.设起始点为A,入口点为B,相遇点为C.设起始点到入口点的距离A->B为X,入口点到相遇点的距离B->C是Z,设相遇点C到入口点B的距离C->B为Y.

4.slow走的路程为X+Z,fast走的路程为X+Z+N*(Z+Y)

5.因为fast是slow速度的两倍,所以路程也是两倍所以2(X+Z)=X+Z+N*(X+Y)

6.化简X = (N-1)*(Z+Y)+Y 表示的是,从起始点到入口点的距离正好 等于 从相遇点开始走(N-1)个环的距离

7.结论:一个从头走,一个从相遇点走,每个人走一步,相遇时,就是入口点.

画图解析:

---

代码实现:

---

/**

• Definition for singly-linked list.

• class ListNode {

• int val;
  

• ListNode next;
  

• ListNode(int x) {
  

最后

小编精心为大家准备了一手资料

以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术

【附】架构书籍

1. BAT面试的20道高频数据库问题解析
2. Java面试宝典
3. Netty实战
4. 算法

BATJ面试要点及Java架构师进阶资料

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
表示的是,从起始点到入口点的距离正好 等于 从相遇点开始走(N-1)个环的距离**

7.结论:一个从头走,一个从相遇点走,每个人走一步,相遇时,就是入口点.

画图解析:

---

代码实现:

---

/**

• Definition for singly-linked list.

• class ListNode {

• int val;
  

• ListNode next;
  

• ListNode(int x) {
  

最后

小编精心为大家准备了一手资料

[外链图片转存中…(img-PhAoHQVN-1713473093498)]

[外链图片转存中…(img-GtmY7DoU-1713473093498)]

以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术

【附】架构书籍

1. BAT面试的20道高频数据库问题解析
2. Java面试宝典
3. Netty实战
4. 算法

[外链图片转存中…(img-Tkb5aBBC-1713473093499)]

BATJ面试要点及Java架构师进阶资料

[外链图片转存中…(img-73FStIvL-1713473093500)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-dydwzjVZ-1713473093501)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！