JZ3.从尾到头打印链表；JZ14.链表中倒数第K个节点；JZ15.反转链表；JZ16.合并两个有序链表；JZ36.两个链表的第一个公共节点；JZ55.链表中环的入口节点；JZ56.删除链表中重复节点
Posted 小猪媛不圆
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JZ3.从尾到头打印链表；JZ14.链表中倒数第K个节点；JZ15.反转链表；JZ16.合并两个有序链表；JZ36.两个链表的第一个公共节点；JZ55.链表中环的入口节点；JZ56.删除链表中重复节点相关的知识，希望对你有一定的参考价值。
剑指Offer——链表
- JZ3. 从尾到头打印链表
- JZ14. 链表中倒数第K个节点
- JZ15. 反转链表
- JZ16. 合并两个有序链表
- JZ36. 两个链表的第一个公共节点
- JZ55. 链表中环的入口节点
- JZ56. 删除链表中重复的节点
JZ3. 从尾到头打印链表
- 程序代码
/**
* public class ListNode
* int val;
* ListNode next = null;
*
* ListNode(int val)
* this.val = val;
*
*
*
*/
import java.util.*;
public class Solution
public ArrayList<Integer> printListFromTailToHead(ListNode listNode)
Stack<Integer> stack = new Stack<>();
ArrayList<Integer> list = new ArrayList<>();
while(listNode != null)
stack.push(listNode.val);
listNode = listNode.next;
while(! stack.isEmpty())
list.add(stack.pop());
return list;
- 简单描述
题目要求按链表从尾到头
返回一个ArrayList，那我们首先想到的就是定义栈，首先把每个节点的值存入栈里，全部存入后，再弹出到链表中，直到栈为空，此时返回的 list 就是从尾到头打印的结果。
JZ14. 链表中倒数第K个节点
- 程序代码
import java.util.*;
/*
* public class ListNode
* int val;
* ListNode next = null;
* public ListNode(int val)
* this.val = val;
*
*
*/
public class Solution
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param pHead ListNode类
* @param k int整型
* @return ListNode类
*/
public ListNode FindKthToTail (ListNode pHead, int k)
// write code here
if(k <= 0) return null;
ArrayList<ListNode> list = new ArrayList<>();
while(pHead != null)
list.add(pHead);
pHead = pHead.next;
int n = list.size();
if(n < k) return null;
return list.get(n-k);
- 简单描述
首先判断如果k的值 <= 0，没有办法返回值，则返回null；
定义一个链表，把节点全部放在链表里，求链表的长度与输入的 k 比较，如果小于 k 的值，则返回null ； 其余情况返回 list.get(n-k)的值
JZ15. 反转链表
- 程序代码
/*
public class ListNode
int val;
ListNode next = null;
ListNode(int val)
this.val = val;
*/
public class Solution
public ListNode ReverseList(ListNode head)
ListNode newHead = null;
ListNode prev = null;
ListNode cur = head;
while(cur != null)
ListNode curNext = cur.next;
if(curNext == null)
newHead = cur;
cur.next = prev;
prev = cur;
cur = curNext;
return newHead;
- 简单描述
要反转一个链表，链表的头节点肯定会变化，所以需要
先定义一个空的引用，同时需要定义一个前驱，定义一个傀儡节点curNext，当curNext的值为空时，说明已经到了链表的尾部，这就是新链表的头节点，各个节点的指向如下图所示，最后返回新的头节点即可。
按照代码里的执行顺序就可以对链表进行逆置
JZ16. 合并两个有序链表
- 程序代码
/*
public class ListNode
int val;
ListNode next = null;
ListNode(int val)
this.val = val;
*/
public class Solution
public ListNode Merge(ListNode list1,ListNode list2)
if(list1 == null && list2 == null) return null;
if(list1 == null) return list2;
if(list2 == null) return list1;
ListNode head = new ListNode(-1);
ListNode res = head;
while(list1 != null && list2 != null)
if(list1.val < list2.val)
head.next = list1;
head = list1;
list1 = list1.next;
else
head.next = list2;
head = list2;
list2 = list2.next;
if(list1 != null) head.next = list1;
if(list2 != null) head.next = list2;
return res.next;
- 简单描述
定义一个头节点，再定义一个节点保存头节点的值为空，当list1和list2都不为空时，判断list1和list2的值的大小，对其进行拼接，退出while循环时，再判断哪个还有剩余，继续对其进行拼接
JZ36. 两个链表的第一个公共节点
- 程序代码
/*
public class ListNode
int val;
ListNode next = null;
ListNode(int val)
this.val = val;
*/
public class Solution
public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2)
if(pHead1 == null || pHead2 == null) return null;
ListNode p1 = pHead1;
ListNode p2 = pHead2;
while(p1 != p2)
p1 = p1.next;
p2 = p2.next;
if(p1 != p2)
if(p1 == null)
p1 = pHead2;
if(p2 == null)
p2 = pHead1;
return p1;
- 简单描述
先判断是否有空，如果有空则没有公共节点。定义p1和p2，当两个节点值不相等时，一直进行循环，不必退出，并且继续往后走，当p1 != p2 且 p1 == null 时，让 p1 = pHead2，p2 同理，最后肯定会相遇，可以参考下面的图进行思考。
JZ55. 链表中环的入口节点
- 程序代码
/*
public class ListNode
int val;
ListNode next = null;
ListNode(int val)
this.val = val;
*/
public class Solution
public ListNode EntryNodeOfLoop(ListNode pHead)
ListNode fast = pHead;
ListNode slow = pHead;
while(fast != null && fast.next != null)
fast = fast.next.next;
slow = slow.next;
if(fast == slow)
break;
//此时退出循环有两种可能
//1是while条件不符合，2是fast == slow 后 break 退出
//所以我们先判断是否是while条件不符合
if(fast == null || fast.next == null)
return null;
fast = pHead;
while(fast != slow)
fast = fast.next;
slow = slow.next;
return slow;
- 简单描述
牛客网上一个牛友讲的很好，以下是摘录的他的呀~
1.这题我们可以采用双指针解法，一快一慢指针。快指针每次跑两个element，慢指针每次跑一个。如果存在一个圈，总有一天，快指针是能追上慢指针的。
2.如下图所示，我们先找到快慢指针相遇的点，p。我们再假设，环的入口在点q，从头节点到点q距离为A，q p两点间距离为B，p q两点间距离为C。
3.因为快指针是慢指针的两倍速，且他们在p点相遇，则我们可以得到等式 2(A+B) = A+B+C+B. （感谢评论区大佬们的改正，此处应为：如果环前面的链表很长，而环短，那么快指针进入环以后可能转了好几圈(假设为n圈)才和慢指针相遇。但无论如何，慢指针在进入环的第一圈的时候就会和快的相遇。等式应更正为2(A+B)= A+ nB + (n-1)C）
4.由3的等式，我们可得，C = A。
5.这时，因为我们的slow指针已经在p，我们可以新建一个另外的指针，slow2，让他从头节点开始走，每次只走下一个，原slow指针继续保持原来的走法，和slow2同样，每次只走下一个。
6.我们期待着slow2和原slow指针的相遇，因为我们知道A=C，所以当他们相遇的点，一定是q了。
7.我们返回slow2或者slow任意一个节点即可，因为此刻他们指向的是同一个节点，即环的起始点，q。
不管是重新建立一个节点slow2，还是让fast = pHead，其实本质都是一样的，我们已经计算出了 A = C ，所以只需要让他们从链表头和相遇点一步步走，终究会在入口点遇见的。
JZ56. 删除链表中重复的节点
- 程序代码
/*
public class ListNode
int val;
ListNode next = null;
ListNode(int val)
this.val = val;
*/
public class Solution
public ListNode deleteDuplication(ListNode pHead)
if(pHead == null || pHead.next == null) return pHead;
ListNode newHead = new ListNode(-1);
newHead.next = pHead;
ListNode prev = newHead;
ListNode cur = newHead.next;
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;
prev.next = cur;
else
prev = cur;
cur = cur.next;
return newHead.next;
- 简单描述
由于头节点可能需要删除，则定义一个
新的newHead节点，再定义出prev和cur，当cur不为空时，判断cur.next是否为空，同时判断cur.val 是否等于 cur.next.val，如果这两个条件都满足，cur 继续往后走，直到条件不满足，其实此时cur的值依然和前面相等，所以我们在退出循环以后，继续让cur再往后走一步，此时让 prev.next = cur，然后继续判断。如果不符合刚刚判断的条件，直接让prev 和 cur都往后走。最后返回newHead.next
以上是关于JZ3.从尾到头打印链表；JZ14.链表中倒数第K个节点；JZ15.反转链表；JZ16.合并两个有序链表；JZ36.两个链表的第一个公共节点；JZ55.链表中环的入口节点；JZ56.删除链表中重复节点的主要内容，如果未能解决你的问题，请参考以下文章
剑指offer(C++)-JZ6：从尾到头打印链表(数据结构-链表)