[leetCode] 369. Plus One Linked List

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

You may assume the integer do not contain any leading zero, except the number 0 itself.

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

方法一

思路：题意是链表加1，就是在链表最后一个node.val+1，因此要处理加1之后的carry情况，还可能会有新的一位出现

例如：第一步：1   ->   2   ->   3 经过reverse

         第二步：dummy   ->   3   ->   2   ->   1

                        pre           cur

         第三步:  再把最后的结果reverse

过程：while循环最后到cur是1这个位置，满足cur!=null，然后cur=cur.next，因此最后cur为null，而pre在cur之前一结点是1这个位置

         因此如果有新的一位出现，就new在pre.next

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

ListNode reverseHead=reverse(head);
ListNode dummy=new ListNode(-1);
dummy.next=reverseHead;
ListNode pre=dummy;
ListNode cur=reverseHead;
int carry=1;

while(cur!=null){
int sum=cur.val+carry;
cur.val=sum%10;
carry=sum/10;
pre=pre.next;
cur=cur.next;
}

a639
if(carry!=0){
pre.next=new ListNode(carry);
}
return reverse(reverseHead);
}

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

方法二

思路：从stack拿到ListNode经过carry这边的计算，不断向ListNode前面添加

过程：                                                               3    ->  null  (rightOne)

                                                          2   ->   rigthOne    (这个时候3这个result赋值成了rightOne)

                                          1  ->   rigthOne            

                                     rigthOne（如果有carry就继续向前面添加）

/**
* Definition for singly-linked list.
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode plusOne(ListNode head) {
if(head==null){
return null;
}
Stack<ListNode> stack=new Stack<>();
while(head!=null){
stack.push(head);
head=head.next;
}

ListNode result=null;
ListNode rightOne=null;
int carry=1;
while(!stack.isEmpty()){
ListNode cur=stack.pop();
int sum=carry+cur.val;
result=new ListNode(sum%10);
carry=sum/10;
result.next=rightOne;                         //result的下一个指向rightOne
rightOne=result;                              //rightOne移到result的位置
}

if(carry!=0){
result=new ListNode(carry);
result.next = rightOne;
}
return result;
}
}