You are given two linked lists representing two non-negative numbers. The most significant digit comes first and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
You may assume the two numbers do not contain any leading zero, except the number 0 itself.
Follow up:
What if you cannot modify the input lists? In other words, reversing the lists is not allowed.
Example:
Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4) Output: 7 -> 8 -> 0 -> 7
这道题就是让做两个链表数据结构的大整数加法。
没啥好说的,限制条件里面说不允许对链表进行reverse,但是这边没有说必须要O(1)的空间复杂度,因此直接用一个Stack,完成从后往前的遍历。
代码贴上来:
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
public class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
if(l1 == null)
return l2;
if(l2 == null)
return l1;
int length1 = getLength(l1);
int length2 = getLength(l2);
if(length1 < length2){
ListNode temp = l2;
l2 = l1;
l1 = temp;
int tmp = length2;
length2 = length1;
length1 = tmp;
}
ListNode p = l1;
for(int i = 0;i<length1-length2;i++){
p = p.next;
}
for(int i = 0;i<length2;i++){
p.val+=l2.val;
p = p.next;
l2 = l2.next;
}
p = l1;
Stack<ListNode> stack = new Stack<>();
while(p!=null){
stack.push(p);
p = p.next;
}
while(!stack.isEmpty()){
ListNode n = stack.pop();
if(stack.isEmpty())
break;
if(n.val>=10){
n.val%=10;
stack.peek().val+=1;
}
}
if(l1.val>=10){
l1.val%=10;
ListNode n = new ListNode(1);
n.next = l1;
l1 = n;
}
return l1;
}
private int getLength(ListNode l){
int counter = 0;
while(l!=null){
counter++;
l = l.next;
}
return counter;
}
}
代码感觉写的还是有些乱,有写地方是一边改一边写的,没有做好优化,但是时间也不是很充足,将就这样吧。