445. 兩數(shù)相加 II
給定兩個非空鏈表來代表兩個非負整數(shù)。數(shù)字最高位位于鏈表開始位置。它們的每個節(jié)點只存儲單個數(shù)字。將這兩數(shù)相加會返回一個新的鏈表。
你可以假設除了數(shù)字 0 之外,這兩個數(shù)字都不會以零開頭。
進階:
如果輸入鏈表不能修改該如何處理?換句話說,你不能對列表中的節(jié)點進行翻轉。
示例:
輸入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
輸出: 7 -> 8 -> 0 -> 7
來源:力扣(LeetCode)
鏈接:https://leetcode-cn.com/problems/add-two-numbers-ii/
著作權歸領扣網(wǎng)絡所有。商業(yè)轉載請聯(lián)系官方授權,非商業(yè)轉載請注明出處。
-
1.使用遞歸 + 反轉
思路:
1.將每個鏈表都進行反轉,之后按照之前的方法一次相加, 思路和上篇文章類似(LeetCode 2. 兩數(shù)相加 - 簡書)
3.相加之后在進行反轉一次即可
- 注意 :要小心鏈表大小不一的情況,獲取空鏈表的變量可能會出現(xiàn) NullPointerException
public static class ListNode {
private int val;
private ListNode next;
public ListNode(int val) {
this.val = val;
}
//用于測試用例
public ListNode(int[] arr) {
if (arr == null || arr.length == 0) throw new NullPointerException("array is Empty");
this.val = arr[0];
ListNode cur = this;
for (int i = 1; i < arr.length; i++) {
cur.next = new ListNode(arr[i]);
cur = cur.next;
}
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
ListNode cur = this;
while (cur != null) {
res.append(cur.val + "->");
cur = cur.next;
}
res.append("NULL");
return res.toString();
}
}
public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode reverseL1 = reverse(l1);
ListNode reverseL2 = reverse(l2);
return reverse(add(reverseL1, reverseL2, 0));
}
public static ListNode add(ListNode l1, ListNode l2, int post) {
if (l1 == null && l2 == null && post == 0) return null;
int x = l1 == null ? 0 : l1.val;
int y = l2 == null ? 0 : l2.val;
int sum = x + y + post;
ListNode node = new ListNode(sum % 10);
node.next = add(l1 == null ? null : l1.next, l2 == null ? null : l2.next, sum / 10);
return node;
}
public static ListNode reverse(ListNode head) {
if (head == null || head.next == null) return head;
ListNode node = reverse(head.next);
head.next.next = head;
head.next = null;
return node;
}
復雜度分析:
時間復雜度:O(max(m , n)), m 和 n 表示兩個鏈表的長度
空間復雜度:O(max(m, n) + ((m + n)+ max(m, n))), 空間復雜度需要將遞歸的復雜度加上新的節(jié)點占用的空間
-
2. 入棧 + 反轉
思路:
- 新建兩個棧,并將兩個鏈表的元素一次入棧
- 每次出棧棧頂元素相加,步驟同上方法
- 最后將新的鏈表反轉一次即可
public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
Stack<ListNode> stack1 = new Stack<>();
Stack<ListNode> stack2 = new Stack<>();
ListNode dummyHead = new ListNode(0);
ListNode prev = dummyHead;
int mod = 0;
while (l1 != null) {
stack1.push(l1);
l1 = l1.next;
}
while (l2 != null) {
stack2.push(l2);
l2 = l2.next;
}
while (!stack1.isEmpty() || !stack2.isEmpty() || mod != 0) {
int x = stack1.isEmpty() ? 0 : stack1.peek().val;
int y = stack2.isEmpty() ? 0 : stack2.peek().val;
int sum = x + y + mod;
mod = sum / 10;
prev.next = new ListNode(sum % 10);
prev = prev.next;
if (!stack1.isEmpty()) stack1.pop();
if (!stack2.isEmpty()) stack2.pop();
}
return reverse(dummyHead.next);
}
復雜度分析:
時間復雜度:O(max(m , n)), m 和 n 表示兩個鏈表的長度
空間復雜度:O(max(m, n) + (m + n) + max(m, n)), 空間復雜度需要將棧的復雜度O(m + n)加上新的節(jié)點占用的空間O(max(m, n)) 和反轉遞歸占用的O(max(m, n))
-
3. 進階(不使用反轉)
思路:
鏈表可能存在幾種情況:
1.鏈表長度相同,不需要進行處理
2.一個鏈表為空,直接返回另一個鏈表即可
3.鏈表長度不同,在短的鏈表前面補0,直到連個鏈表長度相同
- 步驟:
1.將鏈表補齊后,依次相加,暫時先不要處理進位的情況
2.從尾節(jié)點到頭節(jié)點依次遍歷,遇到需要進位的情況,就將前一個節(jié)點加上 mod
3.返回該鏈表即可
public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
if (l1 == null) return l2;
if (l2 == null) return l1;
ListNode cur1 = l1;
ListNode cur2 = l2;
ListNode dummyHead = new ListNode(0);
ListNode prev = dummyHead;
while (cur1 != null && cur2 != null) {
cur1 = cur1.next;
cur2 = cur2.next;
}
if (cur1 != null) { //說明l1長度大于l2,將l2前面補齊
while (cur1 != null) {
prev.next = new ListNode(0);
prev = prev.next;
cur1 = cur1.next;
}
//將部位好的鏈表和短的鏈表進行拼接
prev.next = l2;
cur1 = l1;
cur2 = dummyHead.next;
} else { //l2長度大于l1,將l1前面補齊
while (cur2 != null) {
prev.next = new ListNode(0);
prev = prev.next;
cur2 = cur2.next;
}
prev.next = l1;
cur2 = l2;
cur1 = dummyHead.next;
}
//鏈表進行相加,暫時先不考慮進位情況
ListNode sumHead = new ListNode(0);
ListNode prevSum = sumHead;
while (cur1 != null) {
prevSum.next = new ListNode(cur1.val + cur2.val);
cur1 = cur1.next;
cur2 = cur2.next;
prevSum = prevSum.next;
}
int mod = 0; //余數(shù)
//從尾節(jié)點開始,處理進位情況
while (prevSum != sumHead) {
int sum = prevSum.val + mod;
mod = sum / 10;
prevSum.val = sum % 10;
//需要找到prevSum之前的一個節(jié)點,用于向前遍歷新鏈表
ListNode front = sumHead;
while (front.next != prevSum) {
front = front.next;
}
prevSum = front;
}
//處理最后還需要進位的情況
if (mod > 0) {
ListNode finalNode = new ListNode(mod);
finalNode.next = sumHead.next;
sumHead.next = finalNode;
}
return sumHead.next;
}
復雜度分析:
時間復雜度:O(m + n + max(m , n)), m 和 n 表示兩個鏈表的長度
空間復雜度:O(max(m, n)), 最多只需要占用max(m, n)用來存儲新的節(jié)點
-
測試用例
int[] arr1 = new int[] {7, 2, 4, 3};
int[] arr2 = new int[] {5, 6, 4};
ListNode listNode1 = new ListNode(arr1);
System.out.println(listNode1);
ListNode listNode2 = new ListNode(arr2);
System.out.println(listNode2);
System.out.println("兩數(shù)相加:" + addTwoNumbers(listNode1, listNode2));
-
結果
7->2->4->3->NULL
5->6->4->NULL
兩數(shù)相加:7->8->0->7->NULL
-
源碼
-
我會隨時更新新的算法,并盡可能嘗試不同解法,如果發(fā)現(xiàn)問題請指正
- Github