数据结构（Java）：单链表面试OJ题

1、题一：获取链表倒数第k个节点

1.1 思路解析

此题我们使用双指针法求解。

首先，我们要知道，倒数的第k个节点，距离倒数第一个节点还需要移动k-1次。

1.那么我们可以定义出两个指针，分别为fast和slow，他们初始均值均为头结点head。

2.先让fast指针向后移动k-1次，slow指针保持不动。

3.接着，fast指针和slow指针同步后移，直至fast指针指向最后一个节点。

4.此时，slow指针所指向的位置就是倒数第k个节点。

原理：这个解题思路的原理就是，fast指针和slow指针始终保持着k-1个移动次数，而当fast指针指向最后一个节点（即倒数第一个节点）时，那么slow指针指向的就是倒数第k个节点。

注意事项：

1.k的值是否合法 2.头指针head是否为null

1.2 代码

public int kthToLast(ListNode head, int k) {//当头指针为空时if (head == null) {return Integer.MAX_VALUE;}//当k的值<=0时ListNode cur = head;int size = 0;while (cur != null) {size++;cur = cur.next;}if (k <= 0) {return Integer.MAX_VALUE;}//双指针法求解ListNode fast = head;ListNode slow = head;//先让fast指针移动k-1次int count = 0;while (count != k - 1) {fast = fast.next;//当k值>size时（不合法），fast指针移动的k-1次中，必然会指向nullif (fast == null) {return Integer.MAX_VALUE;}count++;}//slow和fast同步后移，直至fast指向倒数第一个元素（slow和fast始终保持k-1个移动次数）while (fast.next != null) {fast = fast.next;slow = slow.next;}//返回valreturn slow.val;}

2、题二：逆置单链表

2.1 思路解析

此题我们使用头插法求解。

这道题的思路很简单：从第二个节点开始，每得到一个节点，将此节点进行头插操作。

注意：要将最开始的头结点的next置为null（因为链表的头节点在逆置后就变成了尾结点）

2.2 代码

public ListNode reverseList(ListNode head) {//当头结点head为空时if (head == null) {return head;}//获取第二个节点，将第一个节点的next置为nullListNode cur = head.next;head.next = null;//头插while (cur != null) {//先获取当前节点的下一个节点ListNode curN = cur.next;//将当前节点的next指向头结点（头插）cur.next = head;//将head更新为新头插的节点head = cur;//更新cur，继续头插cur = curN;}//返回逆置后的头结点return head;}

3、题三：移除链表元素（删除所有某一数值的节点，且一次循环）

3.1 思路解析

此题我们使用双指针法求解。

1.我们定义两个指针分别为prev（初始指向head头结点即第一个节点）和cur（初始指向head的next节点即第二个节点）。

2.遍历链表。

3.当cur所指节点的值为所要删除的val值时，cur向后移动，prev不动，且将prev的next指针指向移动后的cur，完成节点的删除。

4.若cur所指节点值不是所要删除的val值时，cur和prev同步后移一位。

5.当cur指向null时，遍历完成。

6.经过上述操作，除第一个节点外，其余的节点均已删除完成，我们只需额外判断第一个节点的值是否为要删除的val值即可。

3.2 代码

public ListNode removeElements(ListNode head, int val) {//当head为空时if(head == null) {return head;}//双指针法求解ListNode prev = head;ListNode cur = head.next;while (cur != null) {//判断当前节点的值是否为要删除的val值if (cur.val == val) {//若是，删除节点cur = cur.next;prev.next = cur;}else {//若不是，均向后移动cur = cur.next;prev = prev.next;}}//判断第一个节点的值是否我要删除的val值。if (head.val == val) {head = head.next;}//返回删除后的头结点return head;}

4、题四：获取链表的中间节点

4.1 思路解析

此题我们使用快慢指针法求解。

1.首先，定义两个指针分别为fast和slow。

2.fast指针，每次向后移两位；slow指针，每次向后移一位。

3.链表元素个数为奇数时，当fast.next == null时，slow指向的节点就是中间节点；链表元素个数为偶数时，当fast == null时，slow指向的节点就是中间节点。

注意：

循环结束条件一定要写为：

while（fast != null && fast.next != null）

原因：

1.两者只要有一个不满足就要结束循环，说明已经找到了中间节点

2.一定要fast != null在前，避免fast.next时出现空指针异常

4.2 代码

public ListNode middleNode(ListNode head) {//快慢指针法求解ListNode slow = head;ListNode fast = head;//找中间节点//一定要fast != null在前，避免出现空指针异常//两个条件只要有一个不满足就结束循环，说明到了中间节点的位置while (fast != null && fast.next != null) {ListNode fastN = fast.next;fast = fastN.next;slow = slow.next;}//返回中间节点return slow;}

5、题五：分割链表

5.1 思路解析

1.将链表进行遍历

2.将val < x的节点添加到新链表head1中

3.将val >= x的节点添加到新链表head2中

4.将head1和head2进行拼接

5.返回拼接后新表的头结点head1

注意：

1.无论如何，一定要将head2的最后一个节点next域置为null

2.当表中所以元素的val值都大于等于x时，那么head1将为空表，直接返回head2即可

5.2 代码

public ListNode partition(ListNode pHead, int x) {//当pHead为空时if (pHead == null) {return null;}ListNode cur = pHead;ListNode prev = null;ListNode head1 = null;ListNode head2 = null;ListNode cur1 = null;ListNode cur2 = null;//遍历链表 将val < x的节点添加到新表head1中//将val >= x的节点添加到新表head2中while (cur != null) {if (cur.val < x) {if (head1 == null) {head1 = cur1 = cur;}else {cur1.next = cur;cur1 = cur1.next;}}else {if (head2 == null) {head2 = cur2 = cur;}else {cur2.next = cur;cur2 = cur2.next;}}cur = cur.next;}//注意：需要将head2的最后一个节点的next置为nullif(head2 != null) {cur2.next = null;}//如果旧表中所有元素的val值都大于x，那么head1将会是空表，直接返回head2即可if (head1 == null) {return head2;}//将head1和head2进行拼接cur1.next = head2;return head1;}

6、题六：判断链表是否回文

6.1 思路解析

回文结构，其实就是对称结构：

当元素个数为奇数时：

1.找到中间节点（使用上面的例题已经讲到）

2.以中间节点为头，逆置其后链表

3.逆置后，链表存在下图结构，指针从两端开始比较val值是否相等，直到相遇时结束，若均相等则为回文结构。

当元素个数为偶数时：

1.偶数时，newH和slow无法相遇

2.我们只需额外判断当 newH.next == slow 时，说明为回文结构。

6.2 代码

public boolean chkPalindrome(ListNode A) {// write code hereif (A == null) {return true;}ListNode fast = A;ListNode slow = A;//找中间节点while (fast != null && fast.next != null) {fast = fast.next.next;slow = slow.next;}//逆置中间节点后的链表ListNode cur = slow.next;ListNode curN = null;while (cur != null) {curN = cur.next;cur.next = slow;slow = cur;cur = curN;}//从两端开始遍历，比较值是否相等ListNode newCur = A;while (slow != newCur) {if (slow.val != newCur.val) {return false;}if (newCur.next == slow) {return true;}slow = slow.next;newCur = newCur.next;}return true;}

7、题七：相交链表（找出相交节点）

7.1 思路解析

首先，我们要知道，相交链表的形状为Y形，而非X形：

1.遍历求出各链表的长度，并求得长度的差值len。

2.将较长链表的头指针向后移动len个位置。

3.两个链表的头指针同时后移，会在交点处相遇。

7.2 代码

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {ListNode curA = headA;ListNode curB = headB;int lenA = 0;int lenB = 0;//求链表1的长度while (curA != null) {lenA++;curA = curA.next;//curA发生改变}//求链表2的长度while (curB != null) {lenB++;curB = curB.next;//curB发生改变}//将curA和curB重新指向链表的起始位置curA = headA;curB = headB;//差值int len = lenA - lenB;//将较长的链表头指针后移差值个长度if (len < 0) {len = -len;while (len != 0) {curB = curB.next;len--;}}else {while (len != 0) {curA = curA.next;len--;}}//相遇处即为交点while (curA != curB) {curA = curA.next;curB = curB.next;}return curA;}

8、题八：判断链表是否带环

8.1 思路解析

此题我们使用快慢指针法求解。

1.定义fast为快指针，一次移动两个位置；slow为慢指针，一次移动一个位置。

2.若链表带环，那么这两个指针必定相遇（追击问题）。

注意：

因为fast一次走两步，slow一次走一步，那进入环中后，每次移动，fast和slow之间的距离必定缩短一个节点，那么必定相遇。

（若每次移动两者间缩短的距离不为1时，那么即使有环，也可能不会相遇）

8.2 代码

public boolean hasCycle(ListNode head) {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;}

9、题九：求环的入口点

9.1 思路解析

设：
起点到入口点的长度为X
相遇节点到入口点长度为Y
环的长度为C

因为fast所走路程为slow所走路程的两倍
故：
X + n*C + (C - Y) = 2*(X + C - Y)
则：
X + (2-n)*C = Y
说明：相遇节点到入口点的距离和起点到入口点的距离相等
则，从相遇节点和起点开始相向而行，相遇时的节点就是入口点

注意:我们还需要处理不是环的情况！！！

9.2 代码

public ListNode detectCycle(ListNode head) {//head为空时if (head == null) {return head;}ListNode fast = head;ListNode slow = head;//确定相遇时的节点while (fast != null && fast.next != null) {fast = fast.next.next;slow = slow.next;if (fast == slow) {break;}}//不是环if (fast == null || fast.next == null) {return null;}//从起点和相遇节点开始相向而行，相遇的节点就是入口点ListNode curH = head;while (curH != slow) {curH = curH.next;slow = slow.next;}return slow;}

10、题十：合并两个有序链表

10.1 思路解析

思路很简单，就是从各链表起点开始遍历，比较val值，谁的值小，就插入到新链表当中。

若某一链表的元素全部插入新链表当中后，将另一链表剩余元素直接拼接即可。

10.2 代码

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {//链表为空时if (list1 == null) {return list2;}if (list2 == null) {return list1;}ListNode cur1 = list1;ListNode cur2 = list2;ListNode newH = null;ListNode newCur = null;//从头遍历各链表 谁值小 谁就尾插到新链表中while (cur1 != null && cur2 != null) {if (cur1.val < cur2.val) {if (newH == null) {newH = newCur = cur1;}else {newCur.next = cur1;newCur = newCur.next;}cur1 = cur1.next;}else {if (newH == null) {newH = newCur = cur2;}else {newCur.next = cur2;newCur = newCur.next;}cur2 = cur2.next;}}//某一链表的元素全部插入后，将另一链表剩余元素直接拼接即可if (cur1 == null) {newCur.next = cur2;}if (cur2 == null) {newCur.next = cur1;}return newH;}