324. Wiggle Sort II

题目链接：https://leetcode.com/problems/wiggle-sort-ii/

我的解题思路：先用快排从小到大排序，然后分别将前半段数据和后半段数据依次插入，若有中间数据，则放在最后即是题目要求的格式。

public class Solution {
    public static void wiggleSort(int[] nums) {  
        if(nums.length == 1) return;  
          
        int[] array = new int[nums.length];  
          
        for(int i=0;i<nums.length;i++) {  
            array[i] = nums[i];  
        }  
          
        quickSort(array, 0, nums.length-1);  
          
        int l = 0;  
        int r = nums.length/2;  
        int m = r;  
        int index = 0;  
          
        while(l<m) {  
            nums[index] = array[l];  
            index ++;  
            l++;  
            nums[index] = array[r];  
            index++;  
            r++;  
        }  
          
        if(nums.length % 2 != 0) {  
            nums[nums.length-1] = array[nums.length/2 + 1];  
        }  
    }  
      
    private static void quickSort(int[] nums, int left, int right) {  
        int temp = nums[left];  
        int mLeft = left;  
        int mRight = right;  
          
        while(mLeft<mRight) {  
            while(mLeft<mRight && temp<=nums[mRight])  
               mRight--;  
            if(mLeft<mRight) {  
                swap(nums, mLeft, mRight);
//                nums[mLeft] = nums[mRight];  
//                mLeft ++;  
            }  
            while(mLeft<mRight && temp>=nums[mLeft])  
                mLeft++;  
            if(mLeft<mRight) {  
                swap(nums, mLeft, mRight);
//                nums[mRight] = nums[mLeft];  
//                mRight--;  
            }  
        }  
          
        if(mLeft != left) quickSort(nums,left,mLeft-1);  
        if(mRight != right) quickSort(nums,mRight+1,right);  
    }


    public static void swap(int[] nums, int a, int b) {
        int temp = nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
}

看到有人用JDK提供的API完成数组的拷贝和排序：http://blog.csdn.net/decaywood/article/details/50606725

题意大致为将给定数组中的元素按形如nums[0] < nums[1] > nums[2] < nums[3]….这种样子排列，顺序没要求。

这道题O(1)时间复杂度和空间复杂度的最优解暂时没想出来，用蠢办法解决。方案为先复制当前数组，将复制的数组排序，然后以中位数为界将数组分为两部分，small part和large part。交替填入原始数组即可，这样做的原因是可以避免有值相同的数组挨在一起，以符合题目规则。

交替填入也得注意必须降序交替，否则任然有可能挨在一起。比如[4, 5, 5, 6]这一组如果升序交替填入任然是4、5、5、6，降序则为5、6、4、5

public void wiggleSort(int[] nums) {

        int[] temp = Arrays.copyOfRange(nums, 0, nums.length);
        Arrays.sort(temp);
        int large = temp.length / 2 + (temp.length % 2 == 0 ? -1 : 0);
        int small = temp.length - 1;
        for (int i = 0, j = 1; i < temp.length; i+=2, j+=2) {
            if(j < temp.length) nums[j] = temp[small--];
            nums[i] = temp[large--];
        }
    }

这样实现确实可以，思想和我的一样。

思考答案第一条的思想：https://leetcode.com/problems/wiggle-sort-ii/?tab=Solutions

最主要的是找到中间一个

void wiggleSort(vector<int>& nums) {
    int n = nums.size();
    
    // Find a median.
    auto midptr = nums.begin() + n / 2;
    nth_element(nums.begin(), midptr, nums.end());
    int mid = *midptr;
    
    // Index-rewiring.
    #define A(i) nums[(1+2*(i)) % (n|1)]

    // 3-way-partition-to-wiggly in O(n) time with O(1) space.
    int i = 0, j = 0, k = n - 1;
    while (j <= k) {
        if (A(j) > mid)
            swap(A(i++), A(j++));
        else if (A(j) < mid)
            swap(A(j), A(k--));
        else
            j++;
    }
}