Plus One & Plus One Linked List

Given a non-negative number represented as an array of digits, plus one to the number.

The digits are stored such that the most significant digit is at the head of the list.

Example

Given [1,2,3] which represents 123, return [1,2,4].

Given [9,9,9] which represents 999, return [1,0,0,0].

分析：

这题分两种情况，一种情况是+1后array size 不变，另一种情况是array size 变大了。怎么知道array size会变大呢，就是当我们已经从尾部来到头部，但是carryover却还是1.

public class Solution {
    public int[] plusOne(int[] digits) {
        if (digits == null || digits.length == 0) return digits;

        int carryover = 1;
        int i = digits.length - 1;
        int digit = 0;
        do {
            digit = carryover + digits[i];
            carryover = digit / 10;
            digit = digit % 10;
            digits[i] = digit;
            i--;
        } while(carryover == 1 && i >= 0); 
        // array contains only 9s
        if (carryover == 1) {
            int[] newArray = new int[digits.length + 1];
            newArray[0] = 1;
            return newArray;
        }
        return digits;
    }
}

 

Plus One Linked List

Given a non-negative number represented as a singly linked list of digits, plus one to the number.

The digits are stored such that the most significant digit is at the head of the list.

Example:

Input:
1->2->3

Output:
1->2->4

分析：
递归做法：

/** 
 * Definition for singly-linked list. 
 * public class ListNode { 
 *     int val; 
 *     ListNode next; 
 *     ListNode(int x) { val = x; } 
 * } 
 */  
public class Solution { 
       public ListNode plusOne(ListNode head) {
        if (head == null) return null;

        int carry = helper(head);
        if (carry == 1) {
            ListNode newHead = new ListNode(1);
            newHead.next = head;
            return newHead;
        } else {
            return head;
        }
    }

    public int helper(ListNode head) {
        if (head == null) return 1;

        int carry = helper(head.next);
        int value = head.val;
        head.val = (value + carry) % 10;
        carry = (value + carry) / 10;
        return carry;
    }    
}

方法二：

先reverse, 加一，再reverse.

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }
}

public class Solution {

    private ListNode reverse(ListNode head) {
        ListNode prev = null;
        ListNode current = head;
        ListNode next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        return prev;
    }

    public ListNode plusOne(ListNode head) {
        if (head == null) return head;
        head = reverse(head);
        ListNode newHead = head;
        int carry = 1;
        while (head != null) {
            int value = head.val;
            head.val = (value + carry) % 10;
            carry = (value + carry) / 10;
            head = head.next;
        }
        newHead = reverse(newHead);
        if (carry == 1) {
            ListNode h = new ListNode(1);
            h.next = newHead;
            return h;
        }
        return newHead;
    }
}