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;
}
}