next permutation

fishercoder1534 · fishercoder1534 · commit c9d93f6b275d · 2016-11-29T09:13:32.000-08:00
diff --git a/MEDIUM/src/medium/NextPermutation.java b/MEDIUM/src/medium/NextPermutation.java
@@ -0,0 +1,54 @@
+package medium;
+/**
+ * 31. Next Permutation
+
+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 NextPermutation {
+    /**Leetcode has a very good article to illustrate this problem and with animation: https://leetcode.com/articles/next-permutation/
+     * 1. if the array is already in decrementing order, then there's no next larger permutation possible. 
+     * 2. if not, start from the end of the array, find the first pair of numbers that break the decrementing order
+     * 3. then from that index going to the right again, find the element that is closest bigger than this number, swap them
+     * 4. reverse the right half of this array after this index*/
+    
+    public void nextPermutation(int[] nums) {
+        int i = nums.length-2;
+        while (i >= 0 && nums[i] >= nums[i+1]) {
+            i--;
+        }
+        if (i >= 0) {
+            int j = nums.length-1;
+            while (j >= 0 && nums[i] >= nums[j]) {
+                j--;
+            }
+            
+            swap(nums, i, j);
+        }
+        
+        reverse(nums, i+1);
+    }
+    
+    private void reverse(int[] nums, int start) {
+        int end = nums.length-1;
+        while (start <= end){
+            int tmp = nums[start];
+            nums[start++] = nums[end];
+            nums[end--] = tmp;
+        }
+    }
+
+    private void swap(int[] nums, int i, int j){
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+}
diff --git a/README.md b/README.md
@@ -116,6 +116,7 @@
 |58|[Length of Last Word](https://leetcode.com/problems/length-of-last-word/)|[Solution](../../blob/master/EASY/src/easy/LengthofLastWord.java)|O(n)|O(1)|Easy|
 |56|[Merge Intervals](https://leetcode.com/problems/merge-intervals/)|[Solution](../../blob/master/HARD/src/hard/MergeIntervals.java)|O(n*logn)|O(1)|Hard|
 |43|[Multiply Strings](https://leetcode.com/problems/multiply-strings/)|[Solution]|||Medium
+|31|[Next Permutation](https://leetcode.com/problems/next-permutation)|[Solution](../../blob/master/MEDIUM/src/medium/NextPermutation.java)|O(n)|O(1)|Medium|Array
 |24|[Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/)|[Solution](../../blob/master/EASY/src/easy/SwapNodesinPairs.java)|O(n)|O(1)|Easy| Recursion, LinkedList
 |23|[Merge k Sorted Lists](https://leetcode.com/problems/merge-k-sorted-lists/)|[Solution](../../blob/master/HARD/src/hard/MergeKSortedList.java)|O(n*logk)|O(logk)|Hard|Heap
 |22|[Generate Parentheses](https://leetcode.com/problems/generate-parentheses/)|[Solution](../../blob/master/MEDIUM/src/medium/GenerateParentheses.java)|TBD|O(n)|Medium|Backtracking
