1. 力扣206:反转链表
1.1 题目:
给你单链表的头节点 head
,请你反转链表,并返回反转后的链表。
示例 1:
输入:head = [1,2,3,4,5] 输出:[5,4,3,2,1]
示例 2:
输入:head = [1,2] 输出:[2,1]
示例 3:
输入:head = [] 输出:[]
提示:
- 链表中节点的数目范围是
[0, 5000]
-5000 <= Node.val <= 5000
进阶:链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题?
1.2 思路:
迭代,从头节点开始,一直向新链表头插法插入。
1.3 题解:
/**
* 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 reverseList(ListNode head) {
if (head == null) {
return null;
}
// 新链表的哨兵节点
ListNode dummy = new ListNode(10086, null);
// 头插法
while(head != null){
ListNode p = head.next;
head.next = dummy.next;
dummy.next = head;
head = p;
}
return dummy.next;
}
}
2. 力扣24:两两交换链表中的节点
2.1 题目:
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例 1:
输入:head = [1,2,3,4] 输出:[2,1,4,3]
示例 2:
输入:head = [] 输出:[]
示例 3:
输入:head = [1] 输出:[1]
提示:
- 链表中节点的数目在范围
[0, 100]
内 0 <= Node.val <= 100
2.2 思路:
三个节点的示意图就这样:
2.3 题解:
/**
* 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 dummy = new ListNode(10086, head);
ListNode p = dummy;
// 开始时p是哨兵节点,所以从p的下一个节点和下下个节点开始交换
while(p.next != null && p.next.next != null){
ListNode o1 = p.next;
ListNode o2 = p.next.next;
// 画个简单的示意图,再滤清三个节点之间的关系即可。
o1.next = o2.next;
o2.next = o1;
p.next = o2;
// 由题,p应该前进两个节点位置
p = p.next.next;
}
return dummy.next;
}
}
3. 力扣92:反转链表2
3.1 题目:
给你单链表的头指针 head
和两个整数 left
和 right
,其中 left <= right
。请你反转从位置 left
到位置 right
的链表节点,返回 反转后的链表 。
示例 1:
输入:head = [1,2,3,4,5], left = 2, right = 4 输出:[1,4,3,2,5]
示例 2:
输入:head = [5], left = 1, right = 1 输出:[5]
提示:
- 链表中节点数目为
n
1 <= n <= 500
-500 <= Node.val <= 500
1 <= left <= right <= n
进阶: 你可以使用一趟扫描完成反转吗?
3.2 思路:
一次扫描,时间复杂度O(n),但new了n个节点,空间复杂度较高。
感觉可以不用new,直接把原来链表上的节点直接挪过去,接到只有一个哨兵节点的新链表上,这样空间复杂度也低了非常多。我就不改进了。
3.3 题解;
/**
* 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 reverseBetween(ListNode head, int left, int right) {
// 新链表的哨兵节点
ListNode dummy = new ListNode(10086, null);
ListNode p = dummy;
int k = 1;
// k是遍历旧链表的指针
while(head != null){
// 进这个if,向新链表尾插法
if(k < left){
k++;
p.next = new ListNode(head.val, null);
p = p.next;
} else if (k >= left && k <= right){
// 进这个if,在left和right区间上,向新链表头插法,实现链表的倒序
k++;
ListNode q = new ListNode(head.val, p.next);
p.next = q;
} else if(k > right){
// 进这个if,向新链表尾插法
k++;
while(p.next != null){
p = p.next;
}
p.next = new ListNode(head.val, null);
p = p.next;
}
head = head.next;
}
return dummy.next;
}
}