震惊！双指针解决链表百分之百的问题！
文章目录
- 一.合并两个有序链表【力扣21】
-
- 题目表述
- 解法1、循环+双指针
- 解法2、递归
- 二、删除有序列表的重复元素【力扣83】
-
- 题目表述
- 解法1、常规解法
- 解法2、递归
- 三、环形链表【力扣141】
-
- 题目表述
- 解法：快慢指针相遇问题
- 四、环形链表返回头节点【力扣142】
-
- 题目表述
- 解法
- 五、相交链表【力扣160】
-
- 题目表述
- 解法：相遇
- 大佬算法
- 六、反转链表【力扣206】
-
- 题目表述
- 解法
- 六-1、从尾到头打印链表【剑指offer06】
-
- 题目描述
- 解法
- 七、链表的中间结点【力扣876】
-
- 题目描述
- 解法
- 八、链表中倒数第k个结点【剑指offer22】
-
- 题目描述
- 解法
- 八-1、删除链表的倒数第k个结点，八的升级【力扣19】
-
- 题目描述
- 解法
- 八-2、返回倒数第k个结点 八的升级【力扣面试题02.02】
-
- 题目表述
- 解法
- 九、链表排序【力扣148】
-
- 题目表述
- 解法
一.合并两个有序链表【力扣21】
题目表述
解法1、循环+双指针
- new一个结果链表，一个p节点
- 链表1、2谁小，p.next节点指向谁
- 谁空，p.next就指向另一个链表
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if (l1 == null) return l2;
if (l2 == null) return l1;
ListNode result=new ListNode(0);
ListNode p=result;
while(l1!=null&& l2!=null){
if(l1.val<l2.val){
p.next=l1;
l1=l1.next;
}else{
p.next=l2;
l2=l2.next;
}
p=p.next;
}
if(l1==null) p.next=l2;
if(l2==null) p.next=l1;
return result.next;
}
解法2、递归
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
if (l1 == null) {
return l2;
} else if (l2 == null) {
return l1;
} else if (l1.val < l2.val) {
l1.next = mergeTwoLists(l1.next, l2);
return l1;
} else {
l2.next = mergeTwoLists(l1, l2.next);
return l2;
}
}
二、删除有序列表的重复元素【力扣83】
题目表述
解法1、常规解法
- 创建一个p节点，让p=head.
- 如果p等于p.next,跳过p.next，让p.next=p.next.next
- 如果p不等于p.next,符合题意，p节点移动，p=p.next
- 返回head
public ListNode deleteDuplicates(ListNode head) {
if(head==null) return head;
ListNode p= head;
while(p.next!=null){
if(p.next.val==p.val){
p.next=p.next.next;
}else{
p=p.next;
}
}
return head;
// return p.next;//[1,2]
// return p.next.next;//[2]
// return p.next.next.next;//[]
}
解法2、递归
if(head == null||head.next==null) return head;
head.next=deleteDuplicates(head.next);
return head.val==head.next.val?head.next:head;
三、环形链表【力扣141】
题目表述
- 抓住主要题干：题目给出链表的头节点，判断链表是否有环
解法：快慢指针相遇问题
- 注意健壮性，除了head可能为空,还有构成环的因素
- 慢指针一步走一个节点，快指针一步走两个节点
- 如果相遇，就有环的存在，返回true
- 如果没有，跳出循环，返回false
public class Solution {
public boolean hasCycle(ListNode head) {
if(head==null) return false;
ListNode slow=head;
ListNode quick=head;
// 一个或者两个节点构不成环
while(quick.next!=null&&quick.next.next!=null){
slow=slow.next;
quick=quick.next.next;
if(slow==quick){
return true;
}
}
return false;
}
}
四、环形链表返回头节点【力扣142】
题目表述
- 在141的基础上，返回环的开头节点
解法
如果有环，就让慢指针重新回到开始位置，快慢指针速度均为1，快慢指针再次相遇就是环开头的位置
- 快慢指针第一次相遇是确定环
- 快慢指针第二次相遇是确定环开头的位置
public class Solution {
public ListNode detectCycle(ListNode head) {
Boolean logo=false;
if(head==null) return head;
ListNode slow=head;
ListNode quick=head;
while(quick.next!=null&&quick.next.next!=null){
slow=slow.next;
quick=quick.next.next;
if(slow==quick){
logo=true;
break;
}
}
if(logo==true){
slow=head;
while(slow!=quick){
slow=slow.next;
quick=quick.next;
}
return slow;
}
return null;
}
}
五、相交链表【力扣160】
题目表述
解法：相遇
- 长的链表，节点先移动到与短链表相同长度的位置
- 两个链表的节点在同时移动，如果相同，则相遇
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode ha=headA;
ListNode hb=headB;
int la=0;
int lb=0;
int cha=0;
// while循环，遍历出a,b链表的长度
while(ha.next!=null){
ha=ha.next;
la++;
}
while(hb.next!=null){
hb=hb.next;
lb++;
}
// 对比长度，长度长的链表，统一赋值给ha
if(la<lb){
ha=headB;
hb=headA;
cha=lb-la;
}else{
ha=headA;
hb=headB;
cha=la-lb;
}
// ha先移动到相同长度的位置
for(int i=0;i<cha;i++){
ha=ha.next;
}
while(ha!=null&&hb!=null){
// 如果移动到相同节点，也就是相交节点，就返回该节点
if(ha==hb){
return ha;
}
ha=ha.next;
hb=hb.next;
}
// 没有相遇，就返回空
return null;
}
}
大佬算法
作者：jyd
链接：https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/solution/mian-shi-ti-0207-lian-biao-xiang-jiao-sh-b8hn/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
// 双指针，A指针遍历A链表，再遍历链表B，B指针则反
ListNode A = headA, B = headB;
// 当相遇的时候，返回该时结点
while (A != B) {
// 如果已经遍历完毕，就去遍历另一个链表
A = A != null ? A.next : headB;
B = B != null ? B.next : headA;
}
return A;
}
}
六、反转链表【力扣206】
题目表述
解法
- 临时存储：先创建一个临时节点，用于存储p.next
- 改变指针方向：p的下一个节点方向指向前一个节点
- 改变右内容：代表前节点的pre,继续移动到p的位置
- 改变左内容：此时的p向后移动，等于原先p.next的值
class Solution {
public ListNode reverseList(ListNode head) {
if(head==null) return head;
ListNode pre=null;
ListNode p=head;
while(p!=null){
// 1.先创建一个临时节点，用于存储p.next
ListNode temp=p.next;
// 2.p的下一个节点应该指向前一个节点
p.next=pre;
// 3.代表前节点的pre,继续移动到p的位置
pre=p;
// 4.此时的p向后移动，等于原先p.next的值
p=temp;
}
return pre;
}
}
六-1、从尾到头打印链表【剑指offer06】
题目描述
- 注意：返回的是整型数组
- 数组的长度是固定的，所以设置长度变量
解法
- 注意数组没有add语法
- temp2[i]=pre.val;
class Solution {
public int[] reversePrint(ListNode head) {
int[] temp1=new int[0];
int size=0;
if(head==null) return temp1;
ListNode pre=null;
ListNode p=head;
while(p!=null){
size++;
ListNode tt=p.next;
p.next=pre;
pre=p;
p=tt;
}
int[] temp2=new int[size];
for(int i=0;i<size;i++){
temp2[i]=pre.val;
pre=pre.next;
}
return temp2;
}
}
七、链表的中间结点【力扣876】
题目描述
给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
解法
- 快慢指针，快指针速度为2，慢指针速度为1
class Solution {
public ListNode middleNode(ListNode head) {
ListNode slow=head;
ListNode quick=head;
while(quick!=null&&quick.next!=null){
slow=slow.next;
quick=quick.next.next;
}
return slow;
}
}
八、链表中倒数第k个结点【剑指offer22】
题目描述
- 注意：此题返回的是k以后的链表
解法
- 快慢指针，快指针和慢指针速度一致
- 快指针先走k步，这样慢指针就慢走K步
- 慢指针达到的位置就是倒数第k个结点
class Solution {
public ListNode getKthFromEnd(ListNode head, int k) {
ListNode slow=head;
ListNode quick=head;
for(int i=0;i<k;i++){
quick=quick.next;
}
while(quick!=null){
quick=quick.next;
slow=slow.next;
}
return slow;
}
}
八-1、删除链表的倒数第k个结点，八的升级【力扣19】
题目描述
- 给定一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
解法
- 思路与上面一致
- 最后的连接，要跳过删除的结点
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
if(head.next==null) return null;
ListNode slow=head;
ListNode quick=head;
for(int i=0;i<n;i++){
quick=quick.next;
}
if(quick==null) return head.next;
while(quick.next!=null){
quick=quick.next;
slow=slow.next;
}
slow.next=slow.next.next;
return head;
}
}
八-2、返回倒数第k个结点 八的升级【力扣面试题02.02】
题目表述
解法
- 思路和八一样，快慢指针
- 直接返回值即可，.val
class Solution {
public int kthToLast(ListNode head, int k) {
ListNode slow=head;
ListNode quick=head;
for(int i=0;i<k;i++){
quick=quick.next;
}
while(quick!=null){
slow=slow.next;
quick=quick.next;
}
return slow.val;
}
}
九、链表排序【力扣148】
题目表述
解法
- 归排或者快排，数组是元素组成，而链表是元素+方向，所以要把链表进行拆分
- 只要不断的比较链表的头结点的值，将较短的放入合并后的链表中，并更新头结点就可以了。
- 有位大佬提出虚拟结点，在此引用
public class Offer077 {
public ListNode sortList(ListNode head) {
if (head == null || head.next == null) {
return head;
}
// list 为链表后半段的头结点，在 splitList 函数中完成了将链表从中间截断的处理
ListNode list = splitList(head);
head = sortList(head);
list = sortList(list);
return mergeList(head, list);
}
private ListNode splitList(ListNode head) {
// 为链表增加一个虚拟节点
// 当 fast 达到尾端时，slow 刚好指向前半段链表的最后一个节点
ListNode virtualHead = new ListNode(-1, head);
ListNode fast = virtualHead, slow = virtualHead;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
}
ListNode result = slow.next;
slow.next = null;
return result;
}
private ListNode mergeList(ListNode head1, ListNode head2) {
// 增加虚拟头结点，可以统一操作
// 不用刻意考虑链表中存在空节点的情况，也不用特意增加判断合并后的链表的头结点是什么
ListNode virtualHead = new ListNode();
ListNode node = virtualHead;
ListNode node1 = head1, node2 = head2;
while (node1 != null && node2 != null) {
// 将两个链表中较小的加入到合并后的链表中
if (node1.val <= node2.val) {
node.next = node1;
node1 = node1.next;
} else {
node.next = node2;
node2 = node2.next;
}
node = node.next;
}
if (node1 != null) {
node.next = node1;
} else if (node2 != null) {
node.next = node2;
}
return virtualHead.next;
}
}
作者：huaLuoYueQue
链接：https://leetcode.cn/problems/7WHec2/solution/hua-luo-yue-que-fen-er-zhi-zhi-tu-jie-li-95mj/
来源：力扣（LeetCode）