21. 合并两个有序链表
题目
21. 合并两个有序链表
剑指 Offer 25. 合并两个排序的链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]
解法
迭代
我们可以用迭代的方法来实现上述算法。当 l1 和 l2 都不是空链表时，判断 l1 和 l2 哪一个链表的头节点的值更小，将较小值的节点添加到结果里，当一个节点被添加到结果里之后，将对应链表中的节点向后移一位。
首先，我们设定一个哨兵节点 pre，这可以在最后让我们比较容易地返回合并后的链表。我们维护一个 preCur 指针，我们需要做的是调整它的 next 指针。然后，我们重复以下过程，直到 l1 或者 l2 指向了 null ：如果 l1 当前节点的值小于等于 l2 ，我们就把 l1 当前的节点接在 preCur 节点的后面同时将 l1 指针往后移一位。否则，我们对 l2 做同样的操作。不管我们将哪一个元素接在了后面，我们都需要把 preCur 向后移一位。
在循环终止的时候， l1 和 l2 至多有一个是非空的。由于输入的两个链表都是有序的，所以不管哪个链表是非空的，它包含的所有元素都比前面已经合并链表中的所有元素都要大。这意味着我们只需要简单地将非空链表接在合并链表的后面，并返回合并链表即可。
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
// 虚拟头节点
ListNode pre = new ListNode(-1);
// 用于拼接的临时节点
ListNode preCur = pre;
// 把较小的节点连接到preCur的后面
while (l1 != null && l2 != null) {
if (l1.val < l2.val) {
preCur.next = l1;
l1 = l1.next;
} else {
preCur.next = l2;
l2 = l2.next;
}
preCur = preCur.next;
}
// 把l1和l2之一中的尾部较长的部分拼接到后面
preCur.next = l1 == null ? l2 : l1;
return pre.next;
}
时间复杂度O(n+m)
空间复杂度O(1)
递归
我们直接将以上递归过程建模，同时需要考虑边界情况。
如果 l1 或者 l2 一开始就是空链表 ，那么没有任何操作需要合并，所以我们只需要返回非空链表。否则，我们要判断 l1 和 l2 哪一个链表的头节点的值更小，然后递归地决定下一个添加到结果里的节点。如果两个链表有一个为空，递归结束。
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;
}
}
147. 对链表进行插入排序
题目
147. 对链表进行插入排序
对链表进行插入排序。
插入排序的动画演示如上。从第一个元素开始，该链表可以被认为已经部分排序（用黑色表示）。
每次迭代时，从输入数据中移除一个元素（用红色表示），并原地将其插入到已排好序的链表中。
插入排序算法：
插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。
每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。
重复直到所有输入数据插入完为止。
示例 1：
输入: 4->2->1->3
输出: 1->2->3->4
示例 2：
输入: -1->5->3->4->0
输出: -1->0->3->4->5
解法
从前往后找插入点
插入排序的基本思想是，维护一个有序序列，初始时有序序列只有一个元素，每次将一个新的元素插入到有序序列中，将有序序列的长度增加 1，直到全部元素都加入到有序序列中。
如果是数组的插入排序，则数组的前面部分是有序序列，每次找到有序序列后面的第一个元素（待插入元素）的插入位置，将有序序列中的插入位置后面的元素都往后移动一位，然后将待插入元素置于插入位置。
对于链表而言，插入元素时只要更新相邻节点的指针即可，不需要像数组一样将插入位置后面的元素往后移动，因此插入操作的时间复杂度是 O(1)，但是找到插入位置需要遍历链表中的节点，时间复杂度是 O(n)，因此链表插入排序的总时间复杂度仍然是 O(n^2)，其中 n是链表的长度。
对于单向链表而言，只有指向后一个节点的指针，因此需要从链表的头节点开始往后遍历链表中的节点，寻找插入位置。
对链表进行插入排序的具体过程如下。
- 首先判断给定的链表是否为空，若为空，则不需要进行排序，直接返回。
- 创建哑节点 dummyHead，令 dummyHead.next = head。引入哑节点是为了便于在 head 节点之前插入节点。
- 维护 lastSorted 为链表的已排序部分的最后一个节点，初始时 lastSorted = head。
- 维护 curr 为待插入的元素，初始时 curr = head.next。
- 比较 lastSorted 和 curr 的节点值。
若 lastSorted.val <= curr.val，说明 curr 应该位于 lastSorted 之后，将 lastSorted 后移一位，curr 变成新的 lastSorted。
否则，从链表的头节点开始往后遍历链表中的节点，寻找插入 curr 的位置。令 prev 为插入 curr 的位置的前一个节点，进行如下操作，完成对 curr 的插入：
lastSorted.next = curr.next
curr.next = prev.next
prev.next = curr
- 令 curr = lastSorted.next，此时 curr 为下一个待插入的元素。
- 重复第 5 步和第 6 步，直到 curr 变成空，排序结束。
- 返回 dummyHead.next，为排序后的链表的头节点。
插在prev后面，并且使lastSorted连接上后面的节点
lastSorted.next = curr.next;
curr.next = prec.next;
prev.next = curr;
public ListNode insertionSortList(ListNode head) {
if (head == null || head.next == null) {
return head;
}
ListNode dummyHead = new ListNode(-1);
dummyHead.next = head;
// 链表的已排序部分的最后一个节点
ListNode lastSorted = head;
// 当前遍历到的节点，即待插入的元素
ListNode cur = head.next;
while (cur != null) {
/**
* 比较 lastSorted 和 curr 的节点值。
* 若 lastSorted.val <= curr.val，说明 curr 应该位于 lastSorted 之后，将 lastSorted 后移一位，curr 变成新的 lastSorted。
* 否则，从链表的头节点开始往后遍历链表中的节点，寻找插入 curr 的位置。令 prev 为插入 curr 的位置的前一个节点，完成对 curr 的插入
*/
if (lastSorted.val <= cur.val) {
lastSorted = lastSorted.next;
} else {
ListNode pre = dummyHead;
while (pre.next.val < cur.val) {
pre = pre.next;
}
// 使lastSorted连接上后面的节点
lastSorted.next = cur.next;
// 使curr插在prev后面
cur.next = pre.next;
pre.next = cur;
}
// cur指向下一个待排序节点
cur = lastSorted.next;
}
return dummyHead.next;
}
时间复杂度 n方
148. 排序链表
题目
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
进阶：
你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
示例 1：
输入：head = [4,2,1,3]
输出：[1,2,3,4]
示例 2：
输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]
示例 3：
输入：head = []
输出：[]
解法
前面那个题147要求使用插入排序的方法对链表进行排序，插入排序的时间复杂度是 O( n ^ 2)，其中 n 是链表的长度。
这道题考虑时间复杂度更低的排序算法。题目的进阶问题要求达到 O(nlogn) 的时间复杂度和O(1) 的空间复杂度，时间复杂度是 O(nlogn) 的排序算法包括归并排序、堆排序和快速排序（快速排序的最差时间复杂度是 O(n^2) ），其中最适合链表的排序算法是归并排序。
归并排序基于分治算法。最容易想到的实现方式是自顶向下的递归实现，考虑到递归调用的栈空间，自顶向下归并排序的空间复杂度是 O(logn)。如果要达到 O(1)的空间复杂度，则需要使用自底向上的实现方式。
方法一：自顶向下归并排序
对链表自顶向下归并排序的过程如下。
- 找到链表的中点，以中点为分界，将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 22 步，慢指针每次移动 11 步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点。
- 对两个子链表分别排序。
- 将两个排序后的子链表合并，得到完整的排序后的链表。可以使用「21. 合并两个有序链表」的做法，将两个有序的子链表进行合并。
上述过程可以通过递归实现。递归的终止条件是链表的节点个数小于或等于 1，即当链表为空或者链表只包含 1 个节点时，不需要对链表进行拆分和排序。
public ListNode sortList(ListNode head) {
// 置尾指针为空
return sortList(head, null);
}
public ListNode sortList(ListNode head, ListNode tail) {
// 递归终止条件，链表为空或者链表只包含一个节点时不需要对链表进行拆分和排序
if (head == null) {
return head;
}
if (head.next == tail) {
head.next = null;
return head;
}
// 快慢指针找中间节点，注意这里判断到达末尾是与tail比较
ListNode slow = head;
ListNode fast = head;
while (fast != tail && fast.next != tail) {
slow = slow.next;
fast = fast.next.next;
}
ListNode mid = slow;
// 对前半段和后半段分别进行进行归并排序，然后进行合并,返回合并之后的节点
ListNode list1 = sortList(head, mid);
ListNode list2 = sortList(mid, tail);
return merge(list1, list2);
}
public ListNode merge(ListNode head1, ListNode head2) {
ListNode dummyHead = new ListNode(-1);
ListNode temp = dummyHead;
ListNode cur1 = head1;
ListNode cur2 = head2;
// 将合并指针指向较小节点并使较小节点向后移
while (cur1 != null && cur2 != null) {
if (cur1.val <= cur2.val) {
temp.next = cur1;
cur1 = cur1.next;
} else {
temp.next = cur2;
cur2 = cur2.next;
}
temp = temp.next;
}
// 如果还有没比较到的，拼接到链表后面
if (cur1 != null) {
temp.next = cur1;
} else if (cur2 != null) {
temp.next = cur2;
}
return dummyHead.next;
}
时间复杂度：O(nlogn)，其中 n 是链表的长度。
空间复杂度：O(logn)，其中 n 是链表的长度。空间复杂度主要取决于递归调用的栈空间。
方法二：自底向上归并排序
使用自底向上的方法实现归并排序，不使用递归，则可以达到 O(1) 的空间复杂度。
首先求得链表的长度length，然后将链表拆分成子链表进行合并。
具体做法如下。
- 用 subLength 表示每次需要排序的子链表的长度，初始时subLength=1。
- 每次将链表拆分成若干个长度为 subLength 的子链表（最后一个子链表的长度可以小于 subLength），按照每两个子链表一组进行合并，合并后即可得到若干个长度为 subLength×2 的有序子链表（最后一个子链表的长度可以小于 subLength×2）。合并两个子链表仍然使用「21. 合并两个有序链表」的做法。
- 将subLength 的值加倍，重复第 2 步，对更长的有序子链表进行合并操作，直到有序子链表的长度大于或等于 length，整个链表排序完毕。
public class Solution {
public ListNode sortList(ListNode head) {
int length = getLength(head);
ListNode dummyHead = new ListNode(-1);
dummyHead.next = head;
// 依次将链表分成1块，2块，4块... 每次变换步长，pre指针和cur指针都初始化在链表头
for (int step = 1; step < length; step *= 2) {
ListNode pre = dummyHead;
ListNode cur = dummyHead.next;
while (cur != null) {
// 第一部分头 （第二次循环之后，cur为剩余部分头，不断往后把链表按照步长step分成一块一块...）
ListNode head1 = cur;
ListNode head2 = split(head1, step); // 第二部分头
cur = split(head2, step); // 剩余部分的头
ListNode tmp = merge(head1, head2); // 将一二部分排序合并
pre.next = tmp; // 将前面的部分与排序好的部分连接
while (pre.next != null) {
pre = pre.next; // 把pre指针移动到排序好的部分的末尾
}
}
}
return dummyHead.next;
}
public int getLength(ListNode head) {
int count = 0;
while (head != null) {
head = head.next;
count++;
}
return count;
}
// 切掉链表l的前n个节点，并返回后半部分的链表头。
public ListNode split(ListNode head, int step) {
if (head == null) {
return head;
}
ListNode cur = head;
// 注意这里cur.next!=null 有可能出现后半段还没到规定步长但是走完的情况
for (int i = 1; i < step && cur.next != null; i++) {
cur = cur.next;
}
ListNode right = cur.next; // right为后半段链表头
cur.next = null; // 切断前半段
return right;
}
public ListNode merge(ListNode head1, ListNode head2) {
ListNode dummyHead = new ListNode(-1);
ListNode tmp = dummyHead;
ListNode cur1 = head1;
ListNode cur2 = head2;
while (cur1 != null && cur2 != null) {
if (cur1.val <= cur2.val) {
tmp.next = cur1;
cur1 = cur1.next;
} else {
tmp.next = cur2;
cur2 = cur2.next;
}
tmp = tmp.next;
}
if (cur1 != null) {
tmp.next = cur1;
} else if (cur2 != null) {
tmp.next = cur2;
}
return dummyHead.next;
}
}