LeetCode第2题思悟——两数相加（Add Two Numbers）

第二题

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。（虽然测试有可能不太准确，但是蠢就是蠢，是思路上的差距~没什么好说的）

其实，还有一个收获！明明题目中限定了测试用例非空，但是大神们的代码里还是有对此的检测，我想，这就是良好的编程习惯吧！