两数相加（java）

给出的两个数是正常的正序和倒序的加法区别如下：

如图不难看出，我们只需对对应的两个数相加再加上进位，在计算出下一位的进位即可。

到最后别忘了如果进位不为0，还要加上进位这个节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
       int carry = 0;
       ListNode head = null;
       ListNode cur = null;
       while(l1!=null || l2!=null){
           int n1 = l1 == null?0:l1.val;
           int n2 = l2 == null ? 0 : l2.val;
           int n = n1 + n2 + carry;
           if(head == null){
               head = cur = new ListNode(n%10); 
               
           }else{
               cur.next = new ListNode(n%10);  //给新链表添加节点
               cur = cur.next;
           }
           carry = n/10;
           if(l1 != null) l1 = l1.next;
           if(l2 != null) l2 = l2.next;

       }
       if(carry > 0) cur.next = new ListNode(carry); //如果最后的进位不是0，需要添加节点。
       return head;

    }
}

相似的题：

由于整数取最高位不方便，所以我们也将这两个数和上面的题一样按倒序算加法。

class Solution {
    public List<Integer> addToArrayForm(int[] num, int k) {
        int carry = 0;
        List<Integer> list = new ArrayList<>();
        int i = num.length - 1;
        while(i >= 0 || k > 0){
            int n1 = i >= 0 ? num[i] : 0;
            int n2 = k > 0 ? k%10 : 0;
            int n = n1 + n2 + carry;
            list.add(n%10); 
            carry = n/10;
            i--;
            k = k/10;
        }
        if(carry !=  0){
            list.add(carry);
        }
        Collections.reverse(list);
        return list;
    }
}

又刷到了一道类似的题…

其实这道题就相当于上面那道，只不过是数固定成了1.

class Solution {
    public int[] plusOne(int[] digits) {
        int carry = 0;
        List<Integer> list = new ArrayList<>();
        int n = digits.length-1;
        int i = n;
        while(i >= 0){
            int x = digits[i];
            int x2 = i ==n? 1 : 0;   //只有当数组是最后一个数的时候才和1 和进位相加，别的时候都是加0和进位。
            
            list.add((x + x2 + carry) % 10);
            carry = (x + x2 + carry) /10;  //carry是在add后面的，一开始放到了前面导致错误。
            i--;
        }
        if(carry == 1) 
        list.add(1);
        
       int[] res = new int[list.size()];
       for(i  =0; i < list.size();i++){
           res[i] = list.get(list.size() -1 -i);  //上面的链表是逆序的，应该正过来并且放到数组里。
       }
        return res;
    }
}

class Solution {
    public String addStrings(String num1, String num2) {
          StringBuffer res = new StringBuffer();
        StringBuffer s1 = new StringBuffer(num1);
        StringBuffer s2 = new StringBuffer(num2);
        StringBuffer str1 = s1.reverse();
        StringBuffer str2 = s2.reverse();
        int p1 = 0;
        int p2 = 0;
        int x = 0;
        while(p1 < str1.length() || p2 < str2.length()){
            int a = p1 >= str1.length()? 0 : (int)str1.charAt(p1) - 48;
            int b = p2 >= str2.length()? 0 : (int)str2.charAt(p2) - 48;
            res.append((x + a + b)%10);
            x = (x + a + b)/10;
            p1++;
            p2++;
        }
        if(x == 1)
        res.append(x);
        return res.reverse().toString();
    }
}