【圣诞专场】刷完这套链表套题，面试官考链表的时候我笑出了声

ListNode a=new ListNode(-1,head);

//b节点用来遍历链表

ListNode b=a;

while(b.next!=null){

if(b.next.val==val){

b.next=b.next.next;

}else{

b=b.next;

}

}

//注意这里得写a.next不能写head

return a.next;

}

}

//不设虚拟头结点

class Solution {

public ListNode removeElements(ListNode head, int val) {

//删除值相同的头结点后，可能新的头结点也值相等，用循环解决

while(head!=null&&head.val==val){

head=head.next;

}

if(head==null)

return head;

ListNode prev=head;

//确保当前结点后还有结点

while(prev.next!=null){

if(prev.next.val==val){

prev.next=prev.next.next;

}else{

prev=prev.next;

}

}

return head;

}

}

🌿2.设计链表（中等）

---

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

题目链接：设计链表

这道题能很好检验我们对链表的掌握能力，它需要我们实现指定的功能，大家一定要完成它。

class MyLinkedList {

//虚拟头结点

Node head;

//用来记录元素个数

int N;

class Node{

int val;

Node next;

public Node(){}

public Node(int val){

this.val=val;

}

}

//构造方法

public MyLinkedList() {

this.head=new Node(0);

this.N=0;

}

//获取第index个节点的数值

public int get(int index) {

//如果index非法，返回-1

if (index < 0 || index >= N) {

return -1;

}

Node currentNode = head;

//包含一个虚拟头节点，所以查找第 index+1 个节点

for (int i = 0; i <= index; i++) {

currentNode = currentNode.next;

}

return currentNode.val;

}

//在链表最前面插入一个节点

public void addAtHead(int val) {

addAtIndex(0, val);

}

//在链表的最后插入一个节点

public void addAtTail(int val) {

addAtIndex(N, val);

}

//完成制定插入

public void addAtIndex(int index, int val) {

//非法直接返回

if(index>N){

return;

}

//index<0的情况和等于0是一样的

if(index<0){

index=0;

}

Node curr=head;

//找到待插入位置的前一个节点

for(int i=0;i<index;i++){

curr=curr.next;

}

//完成插入操作

Node newNode=new Node(val);

newNode.next=curr.next;

curr.next=newNode;

N++;

}

public void deleteAtIndex(int index) {

//索引非法直接return

if(index<0||index>=N) return;

Node pre=head;

//找到待插入的前一个节点

for(int i=0;i<index;i++){

pre=pre.next;

}

pre.next=pre.next.next;

N–;

}

}

🌿3.反转链表（简单但重要）

---

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

题目链接：反转链表

非常经典的题目，面试常考，人人都得必会的题！！

方法1双指针迭代：通过两个指针cur和pre，一次一次局部反转，遍历一次后完成全部反转。

class Solution {

public ListNode reverseList(ListNode head) {

//cur在左 pre在右

ListNode pre=head;

ListNode cur=null;

while(pre!=null){

//先保存住pre的next

ListNode a=pre.next;

pre.next=cur;

cur=pre;

pre=a;

}

return cur;

}

}

方法2递归：这道题的递归比较抽象，需要大家自己动手演示一下流程才能想明白，但其实逻辑和双指针是一样的，建议还是掌握双指针方法即可。

class Solution {

public ListNode reverseList(ListNode head) {

//递归出口

if (head == null || head.next == null) {

return head;

}

ListNode newHead = reverseList(head.next);

head.next.next = head;

head.next = null;

return newHead;

}

}

🌿4.两两交换链表中的节点（中等）

---

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

题目链接：两两交换链表中的节点

这道题的思路和上面很像，都是通过指针的思想，一定要去画图，这道题不画图一定会被搞混乱的，看while循环内的代码就能感觉到，再次印证了，做链表题目一定要画图找出执行流程。

cur设为虚拟头结点，为了统一操作，大家一定要养成设置虚拟头结点的习惯。

class Solution {

public ListNode swapPairs(ListNode head) {

if(head==null) return head;

//设置一个虚拟头结点

ListNode dummyHead=new ListNode(-1,head);

ListNode cur=dummyHead;

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

ListNode a=cur.next;

ListNode b=cur.next.next.next;

cur.next=cur.next.next;

cur.next.next=a;

cur.next.next.next=b;

cur=cur.next.next;

}

return dummyHead.next;

}

}

方法二递归：

这里的递归我刚开始也没理解，但是发现一篇很好的关于递归的博客——递归教学

class Solution {

public ListNode swapPairs(ListNode head) {

//终止条件：链表只剩一个节点或者没节点了，没得交换了。返回的是已经处理好的链表

if(head == null || head.next == null){

return head;

}

//一共三个节点:head, next, swapPairs(next.next)

//下面的任务便是交换这3个节点中的前两个节点

ListNode next = head.next;

head.next = swapPairs(next.next);

next.next = head;

//根据第二步：返回给上一级的是当前已经完成交换后，即处理好了的链表部分

return next;

}

}

🌿5.删除链表倒数第N个节点（中等）

---

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

题目链接：删除链表倒数第N个节点

同样是非常经典的题目，解法也有很多，最基础最重要的还是利用快慢双指针加虚拟头节点。大家一定要在反复练习，多看题解区的题解，化他人的知识为自己所用。

class Solution {

public ListNode removeNthFromEnd(ListNode head, int n) {

//快慢指针方法

//定义虚拟头结点

ListNode dummyHead=new ListNode(-1,head);

//定义快慢指针，慢指针负责找到待删除节点的前一个节点

ListNode show=dummyHead;

ListNode fast=dummyHead;

//让fast先走n+1格，当fast走完时刚好show指向倒数第n+1个

for(int i=1;i<=n+1;i++){

fast=fast.next;

}

while(fast!=null){

fast=fast.next;

show=show.next;

}

//删除show指向的下一个节点

show.next=show.next.next;

return dummyHead.next;

}

}

🌿6.链表相交（面试题）

---

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

题目链接：链表相交

这道题在LeetCode被判断为简单题，但是却有一点难度，很多容易被人忽视的小细节，如判断相等时我们应该判断的是节点相等而不是节点的val相等。这里通过长度差，让长短不一的两条链表在末尾对齐的情况下，从同一长度开始遍历，如果有相等的时候直接返回即可，遍历完仍未找到返回null。

方法1：求出长度差统一起始点来遍历判断。

public class Solution {

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

//求出长度差值进行判断

int countA=0;

int countB=0;

ListNode a=headA;

ListNode b=headB;

//求a链表的长度

while(a!=null){

countA++;

a=a.next;

}

//求b链表的长度

while(b!=null){

countB++;

b=b.next;

}

//重置a，b

a=headA;

b=headB;

//如果B更长就交换它们

if(countB>countA){

int temlen=countA;

countA=countB;

countB=temlen;

ListNode temNode=a;

a=b;

b=temNode;

}

//求长度差

int x=countA-countB;

//让a和b同一起跑线（末尾对齐）

while(x–>0){

a=a.next;

}

//同时遍历a和b，遇到相同则返回

while(a!=null){

//是ab而不是a.varb.var

if(a==b) return a;

a=a.next;

b=b.next;

}

//没找到返回Null

return null;

}

}

方法2：我们知道，A和B链表长度可能是不等的，但链表A+B和B+A的长度却是相等的。如果A和B的结尾具有相同的节点，那么A+B和B+A也会有相同的，这样我们就能克服长度不同的困难。

public class Solution {

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

ListNode a=headA;

ListNode b=headB;

//a==b时要么找到了相等，要么两者同时遍历完都为null（都为null时也是相等的情况，所以不会死循环，因为遍历的长度都相等，所以最后没找到相同的情况下，它们会最后同时为null）

while(a!=b){

//如果A遍历完则接着遍历B

a=a!=null?a.next:headB;

//如果B遍历完则接着遍历A

b=b!=null?b.next:headA;

}

//这里a或b都可以。当二者都为null出来说明没有相同的节点，否则就是找到了相同节点

return a;

}

}

🌿7.环形链表（简单）

---

给你一个链表的头节点 head ，判断链表中是否有环。

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

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

题目链接：环形链表

方法1：利用HashSet存储遍历过的节点，如果判断到已存储过返回直接返回true，遍历完的话返回false（时间复杂度O（N），空间复杂度O（N））

public class Solution {

public boolean hasCycle(ListNode head) {

Set set=new HashSet();

ListNode a=head;

while(a!=null){

if(!set.contains(a)){

set.add(a);

}else{

//说明回到了环起点，有环

return true;

}

a=a.next;

}

//遍历完无重复节点，无环

return false;

}

}

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

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

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

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

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

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

如何快速更新自己的技术积累？

• 在现有的项目里，深挖技术，比如用到netty可以把相关底层代码和要点都看起来。
• 如果不知道目前的努力方向，就看自己的领导或公司里技术强的人在学什么。
• 知道努力方向后不知道该怎么学，就到处去找相关资料然后练习。
• 学习以后不知道有没有学成，则可以通过面试去检验。

我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！

以上面试专题的答小编案整理成面试文档了，文档里有答案详解，以及其他一些大厂面试题目

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
本涵盖了95%以上Java开发知识点，真正体系化！**

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

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

如何快速更新自己的技术积累？

• 在现有的项目里，深挖技术，比如用到netty可以把相关底层代码和要点都看起来。
• 如果不知道目前的努力方向，就看自己的领导或公司里技术强的人在学什么。
• 知道努力方向后不知道该怎么学，就到处去找相关资料然后练习。
• 学习以后不知道有没有学成，则可以通过面试去检验。

我个人觉得面试也像是一场全新的征程，失败和胜利都是平常之事。所以，劝各位不要因为面试失败而灰心、丧失斗志。也不要因为面试通过而沾沾自喜，等待你的将是更美好的未来，继续加油！

以上面试专题的答小编案整理成面试文档了，文档里有答案详解，以及其他一些大厂面试题目

[外链图片转存中…(img-rmvic0uc-1713545760299)]

[外链图片转存中…(img-qUgQCyJZ-1713545760301)]

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