Leetcode: 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

Solution: Use Stack, O(N) space

/**
 * 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) {
        Stack<ListNode> st = new Stack<ListNode>();
        while (head != null) {
            st.push(head);
            head = head.next;
        }
        ListNode dummy = new ListNode(-1);
        int carry = 1;
        while (!st.isEmpty() || carry!=0) {
            int num = 0;
            if (!st.isEmpty()) num += st.pop().val;
            if (carry != 0) num += carry;
            ListNode newNode = new ListNode(num%10);
            newNode.next = dummy.next;
            dummy.next = newNode;
            carry = num / 10;
        }
        return dummy.next;
    }
}

my another solution: don't create new node, modify the existed node

public class Solution {
    public ListNode plusOne(ListNode head) {
        Stack<ListNode> st = new Stack<>();
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        while (head != null) {
            st.push(head);
            head = head.next;
        }
        int carry = 1;
        while (carry != 0 && !st.isEmpty()) {
            int num = 0;
            ListNode cur = st.pop();
            num = carry + cur.val;
            cur.val = num % 10;
            carry = num / 10;
        }
        if (carry != 0) {
            ListNode newNode = new ListNode(carry);
            newNode.next = dummy.next;
            dummy.next = newNode;
        }
        return dummy.next;
    }
}

Solution 3: reverse the inputs, add one, then reverse back

Solution 4: Recursion: what kind of alg would adding one in reverse way for list?

Recursion! With recursion, we can visit list in reverse way! 

public ListNode plusOne(ListNode head) {
    if( DFS(head) == 0){
        return head;
    }else{
        ListNode newHead = new ListNode(1);
        newHead.next = head;
        return newHead;
    }
}

public int DFS(ListNode head){
    if(head == null) return 1;
    
    int carry = DFS(head.next);
    
    if(carry == 0) return 0;
    
    int val = head.val + 1;
    head.val = val%10;
    return val/10;
}

Best Solution: Two Pointers, O(1) space

i stand for the right-most non-9 bit, where if there's a carry, i is incremented and the bits after i will be set 0

public class Solution {
    public ListNode plusOne(ListNode head) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode i = dummy;
        ListNode j = dummy;
        
        while (j != null) {
            if (j.val != 9) {
                i = j;
            }
            j = j.next;
        }
        
        i.val++;
        i = i.next;
        while (i != null) {
            i.val = 0;
            i = i.next;
        }
        
        if (dummy.val == 0) {
            return dummy.next;
        }
        
        return dummy;
    }
}