代码随想录第四天|没完全掌握的题24、142方便以后二刷有目标
Leetcode 24 两两交换链表中的节点
题目链接: 两两交换链表中的节点
自己的思路:迭代和递归。迭代:以链表1–>2–>3–>4–>5–>null为例,定义一个虚拟头结点,可以避免很多边界判断,定义一个临时结点cur=dummyhead,cur位于需要调换的两个结点的前面一个结点,首先改变虚拟头结点cur的指向,即cur.next=2,然后改变2.next=1,进而改变1.next=3,这样就可以完成一个小单元的迭代,所以需要存一下1和3的临时结点,然后cur需要前移两个位置才可以,因为cur必须位于需要调换的两个结点的前面一个结点,然后重复此过程。
正确思路:迭代、递归
迭代代码:
/**
* 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 swapPairs(ListNode head) {
//定义一个虚拟头结点
ListNode dummyhead = new ListNode(0,head);
ListNode cur = dummyhead;
//因为迭代的过程中存在cur.next.next.next,所以cur.next.next不可以为null
while(cur.next!=null&&cur.next.next!=null){
//定义两个临时结点
ListNode temp1 = cur.next;
ListNode temp2 = cur.next.next.next;
//改变指向
cur.next = cur.next.next;
cur.next.next = temp1;
temp1.next = temp2;
cur = cur.next.next;
}
//返回新的链表的头结点
return dummyhead.next;
}
}
复杂度分析:
时间复杂度:
O
(
n
)
\mathcal{O}(n)
O(n)
空间复杂度:
O
(
1
)
\mathcal{O}(1)
O(1)
递归思路:始终记住递归函数的作用是交换两个链表的结点。
递归代码:
/**
* 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 swapPairs(ListNode head) {
//终止条件
if (head==null||head.next==null) return head;
//始终记住swapPairs是交换两个链表的结点
//假设链表是 1->2->3->4
//保存节点2
ListNode temp = head.next;
//继续递归,处理节点3->4
//当递归结束返回后,就变成了4->3
//于是head节点就指向了4,变成1->4->3
head.next = swapPairs(temp.next);
//将2节点指向1
temp.next = head;
return temp;
}
}
复杂度分析:
时间复杂度:
O
(
n
)
\mathcal{O}(n)
O(n)
空间复杂度:
O
(
1
)
\mathcal{O}(1)
O(1)
Leetcode 19 删除链表的倒数第 N 个结点
题目链接: 删除链表的倒数第 N 个结点
自己的思路:可以假设一个虚拟头结点,避免一些边界的判断。采用双指针的方法来处理,定义一个快指针为虚拟头结点先在前面走,走n+1步之后,再让慢指针和快指针同时走,直到快指针为null为止,慢指针就可以指向倒数第n个结点之前的一个结点。分析原理:假设链表长度为l,快指针先走n+1步的话,则剩下要走的步数为l-n-1,慢指针走l-n-1步之后,就会剩下n+1个结点,那么慢指针就在要删除的结点之前。
正确思路:双指针
代码:
/**
* 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 removeNthFromEnd(ListNode head, int n) {
//新建一个虚拟头结点
ListNode dummyhead = new ListNode(0,head);
ListNode fast = dummyhead;
//先让fast指针走n+1步,这样可以让slow指向要删除的结点的前一个
while(n!=0&&fast!=null){
fast = fast.next;
n--;
}
fast = fast.next;
//fast指针走完n+1步,slow指针再开始走
ListNode slow = dummyhead;
while(fast!=null){
fast = fast.next;
slow = slow.next;
}
//删除节点
slow.next = slow.next.next;
//返回头结点
return dummyhead.next;
}
}
复杂度分析:
时间复杂度:
O
(
n
)
\mathcal{O}(n)
O(n)
空间复杂度:
O
(
1
)
\mathcal{O}(1)
O(1)
Leetcode 面试题 02.07 链表相交
题目链接: 链表相交
自己的思路:假设两个链表存在交点,链表A单独的链表长度为a,链表B单独的链表长度为b,共同的链表长度为c,那么定义两个指针,heada指针初始化为headA结点,headb指针初始化为headB结点,先让heada指针遍历一遍链表A,然后再让heada指针走一遍链表B单独的链表,则遍历的链表总长度为a+c+b;同理,headb指针遍历的链表总长度为b+c+a;走的路径数相等,所以最后停的时候就是两个链表的交点。
正确思路:双指针
代码:
/**
* 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) {
ListNode heada = headA;
ListNode headb = headB;
while(heada!=headb){
//结点遍历
heada = heada==null?headB:heada.next;
headb = headb==null?headA:headb.next;
}
return heada;
}
}
复杂度分析:
时间复杂度:
O
(
a
+
b
)
\mathcal{O}(a+b)
O(a+b)
空间复杂度:
O
(
1
)
\mathcal{O}(1)
O(1)
Leetcode 142 环形链表 II
题目链接: 环形链表 II
自己的思路:该题记住结论即可,三指针寻找环形链表入口。先定义快慢指针来寻找两个指针的交点,然后定义一个临时结点,慢指针和临时结点同时走,交点即为环形链表的入口。
正确思路:三指针。
代码:
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode detectCycle(ListNode head) {
//定义快慢指针
ListNode fast = head;
ListNode slow = head;
while(fast!=null&&fast.next!=null){
fast = fast.next.next;
slow = slow.next;
//快慢指针交点
if (fast==slow){
ListNode cur = head;
//找环形链表入口
while(cur!=slow){
slow = slow.next;
cur = cur.next;
}
return slow;
}
}
return null;
}
}
复杂度分析:
时间复杂度:
O
(
n
)
\mathcal{O}(n)
O(n)
空间复杂度:
O
(
1
)
\mathcal{O}(1)
O(1)