第二题
1. 题目要求
You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order 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.
(给定两个非空链表来表示两个非负整数。位数按照逆序方式存储,它们的每个节点只存储单个数字。将两数相加返回一个新的链表。
你可以假设除了数字 0 之外,这两个数字都不会以零开头。)
2. 示例
Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807.
3. 我的思路
首先是逆序链表表示一个整数,也就是说链表中前面的数字在正常计算中要先计算;结果也是逆序表示的链表,所以正常计算中先计算的结果要先出现在结果链表中;这是从问题到解法的一个基本转化;从该转化中我们得到了我们需要的数据结构:先访问的链表节点先计算——先进先出的队列~先计算得到的结果先出现在结果链表中——先进先出的队列;
之后就是计算上要考虑的几种情况:位数长度不一致、进位问题。关于位数长度不一致,我的处理方法是分两部分计算:一部分是两个操作数相加,另一部分是一个操作数相加;进位问题不是很难处理,只需要一个中间变量记录即可;一个可能忽略的问题就是当两个数位数一样又产生了进位时,需要往结果中添加一个1。关于这题,我的思悟是第一遍编译没有通过是因为我在第二部分的处理中,忘记了poll(),结果死循环了;第二遍提交后结果错,因为刚开始我使用的是栈!不是队列!这是因为我没有真正理清这里的操作关系,然后平时使用栈比较多,有一点思维定式!真正静下来思考后,得到了上面的思路;
代码如下(49 ms):
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ArrayDeque<Integer> firstQueue=new ArrayDeque<>();
ArrayDeque<Integer> secondQueue=new ArrayDeque<>();
ArrayList<Integer> resultList=new ArrayList<>();
ArrayDeque<Integer> nextStack;
ListNode currentNode=l1;
while(currentNode!=null){
firstQueue.add(currentNode.val);
currentNode=currentNode.next;
}
currentNode=l2;
while(currentNode!=null){
secondQueue.add(currentNode.val);
currentNode=currentNode.next;
}
int carryBit=0;
int currentResult;
Integer firstNum,secondNum;
while((firstNum=firstQueue.peek())!=null&&(secondNum=secondQueue.peek())!=null){
currentResult=firstNum+secondNum+carryBit;
if(currentResult>=10){
currentResult-=10;
carryBit=1;
}else{
carryBit=0;
}
resultList.add(currentResult);
firstQueue.poll();
secondQueue.poll();
}
if(firstQueue.size()==0){
nextStack=secondQueue;
}else{
nextStack=firstQueue;
}
while((firstNum=nextStack.peek())!=null){
currentResult=firstNum+carryBit;
if(currentResult>=10){
currentResult-=10;
carryBit=1;
}else{
carryBit=0;
}
nextStack.poll();
resultList.add(currentResult);
}
if(carryBit==1){
resultList.add(1);
}
ListNode resultHead=new ListNode(-1);
ListNode currentTail=resultHead;
int length=resultList.size();
for(int i=0;i<length;i++){
currentTail.next=new ListNode(resultList.get(i));
currentTail=currentTail.next;
}
return resultHead.next;
}
4. 大神们解法
//35ms
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
ListNode result=null;
ListNode index=null;
int tmpTotal=0;
boolean isFirst=true;
boolean isAdd1=false;
int l1val=0,l2val=0;
while(l1!=null||l2!=null||isAdd1) {
if(l1!=null) {
l1val=l1.val;
l1=l1.next;
}
if(l2!=null) {
l2val=l2.val;
l2=l2.next;
}
tmpTotal = (l1val+l2val);
if(isAdd1) {
tmpTotal++;
isAdd1 = false;
}
if(tmpTotal>=10) {
tmpTotal-=10;
isAdd1=true;
}
ListNode tmp = new ListNode(tmpTotal);
l1val=0;l2val=0;tmpTotal=0;
if(isFirst) {
result = tmp;
index=result;
isFirst=false;
continue;
}
index.next = tmp;
index=tmp;
}
return result;
}
//32ms
public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//==========预处理,保证计算不出nullpointer错
if(l1 == null){
l1 = new ListNode(0);
}
if(l2 == null){
l2 = new ListNode(0);
}
//========================================
if(l1.next==null && l2.next==null){//最小情况
int val = l1.val+l2.val;
if(val>9){
ListNode node = new ListNode(val%10);//设置第二位
node.next = new ListNode(val/10);//设置第一位
return node;
}else
return new ListNode(val);
}else {//可继续迭代的情况
int val = l1.val+l2.val;
if(val>9){
val = val-10;
if(l1.next!=null) l1.next.val++;
else if(l2.next!=null) l2.next.val++;
//else //不存在的,必为上述两种情况之一。
}
ListNode node = new ListNode(val);
//开始迭代
node.next = addTwoNumbers(l1.next,l2.next);
return node;
}
}
32ms和35ms的解法思路有一点不同,一个使用while循环,一个使用递归;但是他们的共同点是在对链表的访问过程中建立了结果链表;而我是先将链表存入了队列中,然后将计算得到的所有结果数据存在了链表里,之后再遍历一遍链表生成结果链表;这样就比大神们的解法多了对链表的插入和遍历访问的时间;这是因为我“吸取”上一题教训,活用数据结构,结果为了“数据结构”而“数据结构”了,现在看来很多此一举,明明可以访问的时候就处理,非要把它放到队列里然后再处理,于是就差了10ms。(虽然测试有可能不太准确,但是蠢就是蠢,是思路上的差距~没什么好说的)
其实,还有一个收获!明明题目中限定了测试用例非空,但是大神们的代码里还是有对此的检测,我想,这就是良好的编程习惯吧!