LeetCode Wiggle Sort II

原题链接在这里：https://leetcode.com/problems/wiggle-sort-ii/

题目：

Given an unsorted array nums, reorder it such that nums[0] < nums[1] > nums[2] < nums[3]....

Example:
(1) Given nums = [1, 5, 1, 1, 6, 4], one possible answer is [1, 4, 1, 5, 1, 6]. 
(2) Given nums = [1, 3, 2, 2, 3, 1], one possible answer is [2, 3, 1, 3, 1, 2].

Note:
You may assume all input has valid answer.

Follow Up:
Can you do it in O(n) time and/or in-place with O(1) extra space?

题解：

先通过Kth Largest Element in an Array找出median.

再把小于median的放在low位, 大于median的放在high位.

When we assign value to low index and high index, we need to consider n is odd and even, 2 cases.

e.g. 44456, median is 4, we need to put high index as n - 1, and every time high -=2.

4556, median is 5, here we need to put low index as n - 1, and every time low -= 2. 

If for 4556, we also put high index as n - 1, we will get 5555 -> 4556, there are two 5 close to each other.

Note: eventually we need to assign res back to nums one by one, but not nums = res. Since it is checking heap, but not stack. nums is a variable in stack, it is pointing to realy memory in heap.

Time Complexity: O(n). Space: O(n).

AC Java:

class Solution {
    public void wiggleSort(int[] nums) {
        if(nums == null || nums.length < 2){
            return;
        }
        
        int n = nums.length;
        int median = findK(nums, 0, n - 1, n / 2);
        int [] res = new int[n];
        Arrays.fill(res, median);
        
        if(n % 2 == 1){
            int low = 0;
            int high = n - 2;

            for(int num : nums){
                if(num < median){
                    res[low] = num;
                    low += 2;
                }else if(num > median){
                    res[high] = num;
                    high -= 2;
                }
            }
        }else{
            int low = n - 2;
            int high = 1;
            for(int num : nums){
                if(num < median){
                    res[low] = num;
                    low -= 2;
                }else if(num > median){
                    res[high] = num;
                    high += 2;
                }
            }
        }
        
        
        for(int i = 0; i < n; i++){
            nums[i] = res[i];
        }
    }
    
    private int findK(int [] nums, int l, int r, int k){
        if(l >= r){
            return nums[l];   
        }
        
        int m = partition(nums, l, r);
        if(m == k){
            return nums[m];
        }else if(m < k){
            return findK(nums, m + 1, r, k);
        }else{
            return findK(nums, l, m - 1, k);
        }
    }
    
    private int partition(int [] nums, int l, int r){
        int pivot = nums[l];
        while(l < r){
            while(l < r && nums[r] >= pivot){
                r--;
            }
            
            nums[l] = nums[r];
            
            while(l < r && nums[l] <= pivot){
                l++;
            }
            
            nums[r] = nums[l];
        }
        
        nums[l] = pivot;
        return l;
    }
}

类似Wiggle Sort.