6、反转链表
反转一个单链表。
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode reverseList(ListNode head) {
ListNode pre = null;
while (head != null) {
ListNode next = head.next;
head.next = pre;
pre = head;
head = next;
}
return pre;
}
}
7、反转链表 II
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode reverseBetween(ListNode head, int m, int n) {
if (m == n) return head;
//由于在本题中head节点有可能发生变化当m=1时,所以需要一个dummy节点
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode begin = dummy;
//begin节点为m节点前面的节点
ListNode cur = head;
for (int i = 0; i < m - 1; i++) {
begin = begin.next;
cur = cur.next;
}
ListNode pre = cur, end = cur;
//pre和end此时都指向m节点,end指m节点,为了后面m节点指向n后面的节点
cur = cur.next;
for (int j = 0; j < n - m; j++) {
ListNode next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
//m前面的节点指向n
begin.next = pre;
//m节点指向n后面的节点
end.next = cur;
return dummy.next;
}
}
8、相交链表
编写一个程序,找到两个单链表相交的起始节点。
/**
* 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 p = headA, q = headB;
while (p != q) {
p = p == null ? headB : p.next;
q = q == null ? headA : q.next;
}
return p;
//如果没有交点,p == q == null返回
}
}
9、环形链表II
给定一个链表,返回链表开始入环的第一个节点。 如果链表无环,则返回 null
。
说明:不允许修改给定的链表。
/**
* 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, slow = head;
while (slow != null) {
slow = slow.next;
fast = fast.next;
if (fast != null && fast.next != null) fast = fast.next;
else break;
//fast == null || fast.next == null,说明该链表没有环
if (fast == slow) {
//相遇在m点
slow = head;
while (slow != fast) {
slow = slow.next;
fast = fast.next;
}
return slow;
}
}
return null;
}
}
10、排序链表
在 O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序。
在递归时会用到O(logn)的空间复杂度,所以我们要使用自底向上的归并排序,迭代版。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode sortList(ListNode head) {
//由于head节点可能会变,所以需要一个虚拟头节点
ListNode dummy = new ListNode(-1);
dummy.next = head;
ListNode cur = dummy;
int n = 0;
while (cur.next != null) {
n++;
cur = cur.next;
}
for (int i = 1; i < n; i *= 2) {
//每轮归并的宽度,第一次1,第二次2,直到i == n时代表归并完毕,归并logn次
cur = dummy;
for (int j = 0; j + i < n; j += i * 2) {
ListNode left = cur.next, right = left;
for (int k = 0; k < i; k++) right = right.next;
int l = 0, r = 0;
while (l < i && r < i && right != null) {
if (left.val <= right.val) {
cur.next = left;
cur = left;
left = left.next;
l++;
} else {
cur.next = right;
cur = right;
right = right.next;
r++;
}
}
while (l < i) {
cur.next = left;
cur = left;
left = left.next;
l++;
}
while (r < i && right != null) {
cur.next = right;
cur = right;
right = right.next;
r++;
}
//由于之前的right = right.next,所以
cur.next = right;
//cur指向right的下一个节点
}
}
return dummy.next;
}
}
最难点应该在于j + i < n的理解。
1-2-3-4-5
1、第一次归并时,i = 1,1,2,3, 4,5各一组。
j从0,变为2,变为4,当j = 4时,j + i = 5 == n,所以当left存在而right不存在时,放弃这次合并。
2、第二次归并时,i = 2,12一组和34一组进行归并,5一组。
j从0,变为4,j + i = 6 > n,所以在第二轮5依旧不参与归并。
3、第三次归并时,i = 4,1234一组和5一组进行归并。
当j = 0时,j + i = 4 < n,所以5是参与归并的。
结论:
在找right部分时,如果right部分不存在,则放弃此次归并;如果right部分存在,但是长度小于i,则也要归并。