Add Two Numbers, Next Permutation

Author: mengli

Add Two Numbers.java

@@ -0,0 +1,51 @@
+You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
+
+Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
+Output: 7 -> 0 -> 8
+
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        if (l1 == null) return l2;
+        if (l2 == null) return l1;
+        ListNode head = new ListNode(0);
+        ListNode cur = head;
+        int plus = 0;
+        while (l1 != null && l2 != null) {
+            int sum = l1.val + l2.val + plus;
+            plus = sum / 10;
+            sum = sum % 10;
+            cur.next = new ListNode(sum);
+            cur = cur.next;
+            l1 = l1.next;
+            l2 = l2.next;
+        }
+        if (l1 != null) {
+            if (plus != 0) {
+                cur.next = addTwoNumbers(l1, new ListNode(plus));
+            } else {
+                cur.next = l1;
+            }
+        } else if (l2 != null) {
+            if (plus != 0) {
+                cur.next = addTwoNumbers(l2, new ListNode(plus));
+            } else {
+                cur.next = l2;
+            }
+        } else if (plus != 0) {
+            cur.next = new ListNode(plus);
+        }
+        
+        return head.next;
+    }
+}

Next Permutation.java

@@ -0,0 +1,37 @@
+Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.
+
+If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).
+
+The replacement must be in-place, do not allocate extra memory.
+
+Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.
+1,2,3 ¡ú 1,3,2
+3,2,1 ¡ú 1,2,3
+1,1,5 ¡ú 1,5,1
+
+public class Solution {
+    public void nextPermutation(int[] num) {
+        int i1 = 0;
+        int i2 = 0;
+        int i = num.length - 1;
+        int j = 0;
+        while (i > 0 && num[i - 1] >= num[i]) {
+            i--;
+        }
+        if (i == 0) {
+            Arrays.sort(num);
+            return;
+        } else {
+            i1 = i - 1;
+        }
+        j = i1 + 1;
+        while (j < num.length && num[i1] < num[j]) {
+            j++;
+        }
+        i2 = j - 1;
+        int temp = num[i1];
+        num[i1] = num[i2];
+        num[i2] = temp;
+        Arrays.sort(num, i1 + 1, num.length);
+    }
+}