【一次过】Lintcode 904. 加一链表

给定一个非负整数，这个整数表示为一个非空的单链表，每个节点表示这个整数的一位。返回这个整数加一。

除了0本身，所有数字在最高位前都没有0。

列表的头节点存的是这个整数的最高位。

样例

给出链表1 -> 2 -> 3 -> null，返回 1 -> 2 -> 4 -> null。

---

解题思路：

因为可能头节点会变化，所以设置dummy结点，特别地，将dummy.val = 1，因为当9，99，999的时候+1，均会多出一个节点1。所以可以利用这个dummy节点可能当作这个节点。

基本思想是，设置tail和node两个节点，分别指向尾部和尾部前一个节点，依次循环向前遍历加一，最后特别考虑头节点进位增加节点的情况。

/**
 * Definition for ListNode
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */

public class Solution {
    /**
     * @param head: the first Node
     * @return: the answer after plus one
     */
    public ListNode plusOne(ListNode head) {
        // Write your code here
        if(head == null)
            return null;
        
        ListNode dummy = new ListNode(1);
        dummy.next = head;
        
        ListNode tail = null;
        int cnt = 1;
        
        //循环向前遍历加一
        while(cnt != 0 && tail != head){
            ListNode node = head;
            
            while(node.next != tail)
                node = node.next;
            
            int sum = node.val + cnt;
            node.val = sum % 10;
            cnt = sum / 10;
        
            tail = node;
        }
        
        //考虑最后头节点前添加1的情况
        if(cnt != 0)
            return dummy;
        else
            return dummy.next;
    }
}

二刷：先将链表翻转，然后按位加一，最后再将链表翻转即可。

/**
 * Definition for ListNode
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */

public class Solution {
    /**
     * @param head: the first Node
     * @return: the answer after plus one
     */
    public ListNode plusOne(ListNode head) {
        // Write your code here
        ListNode node = reverse(head);
        ListNode cur = node;
        ListNode pre = null;
        int cnt = 1;
        
        //依次按位加
        while(cur != null){
            int temp = cur.val + cnt;
            cur.val = temp%10;
            cnt = temp/10;
            
            pre = cur;
            cur = cur.next;
        }
        
        //若最高位有进位则再插入一个节点
        if(cnt != 0)
            pre.next = new ListNode(cnt);
        
        return reverse(node);
    }
    
    private ListNode reverse(ListNode head){
        ListNode pre = null;
        ListNode cur = head;
        
        while(cur != null){
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        
        return pre;
    }
}