diff --git a/solutions/324. Wiggle Sort II.md b/solutions/324. Wiggle Sort II.md
new file mode 100644
index 0000000..9ea9080
--- /dev/null
+++ b/solutions/324. Wiggle Sort II.md	
@@ -0,0 +1,122 @@
+# [324. Wiggle Sort II](https://leetcode.com/problems/wiggle-sort-ii/)
+
+# 思路
+题目给定一个无序数组，让我们排序成摆动数组，满足nums[0] < nums[1] > nums[2] < nums[3]...。
+
+## 思路一
+我们可以先给数组排序，知道每个数的大小关系后就好按照题意进行调整了。
+我们从中间把有序数组从中间分成两部分：
+1. 前半部分S: nums[0,...,n/2)；
+2. 后半部分B: nums[n/2,...,n-1]。
+
+这样就保证了B段所有数都大于等于S段的所有数。然后从前半段S的末尾取一个，在从后段B的末尾去一个，这样保证了第一个数小于第二个数，然后从前半段取倒数第二个，从后半段取倒数第二个，这保证了第二个数大于第三个数，且第三个数小于第四个数，以此类推直至都取完。
+
+> 需要注意的是，因为存在重复元素，所以我们需要把S中比较大的数和B中比较小的数放的越远越好。所以应该先取S中较大的数，最后取B中较小的数，即必须都从末尾开始取。
+比如当数组为[1,2,2,3]时，只有都从末尾取才能得到正确结果[2,3,1,2]。
+
+
+由于排序的时间复杂度为O(nlogn), 所以时间复杂度为O(nlogn)。最后交替取数的时候需要开辟一个数组备份排好序的nums，所以空间复杂度为O(n)。
+
+## 思路二
+思路一排序的目的仅仅是等分成两段S和B使S中的元素都不大于B中的元素，那么我们完全没必要排序，只需要找到中位数然后根据中位数划分就行了。
+
+1. 我们可以用O(n)的时间复杂度和O(1)空间复杂度查找数组中第k大的数，这就是第[215题](https://github.com/ShusenTang/LeetCode/blob/master/solutions/215.%20Kth%20Largest%20Element%20in%20an%20Array.md)干的事情，这里我们用STL中现成的函数`nth_element`：
+  ``` C++
+  nth_element(vc.begin(), vc.begin()+k, vc.end()); // 保证第 k 小的元素在第k个位置（返回空！）
+  ```
+2. 找到中位数后，需要将数组划分为三段依次为：大于中位数（L）、等于中位数（M）和小于中位数（S），即荷兰国旗问题，即[75题](https://github.com/ShusenTang/LeetCode/blob/master/solutions/75.%20Sort%20Colors.md)干的事情，采用快排划分的思想，时间复杂度O(n)，空间复杂度O(1)。
+
+然后就可以按照思路一的交替取值思想获得最终结果了。时间复杂度为O(n)，由于还是要交替取数，所以需要开辟备份数组，空间复杂度为O(n)。
+
+## 思路二空间改进版
+思路二最后的交替取值实际上是将索引重新映射的过程，而且这个映射是固定的。举两个例子
+```
+例 1
+n = 5
+索引:           0 1 2  3 4
+交替取值后的索引: 4 2 0  3 1
+
+例 2
+n = 6
+索引:           0 1 2  3 4 5
+交替取值后的索引: 4 2 0  5 3 1
+```
+仔细观察可得出这个固定的映射是`func(i) = (2*n - 2*i - 1) % (n | 1)`，所以我们可以在划分的时候就进行这个映射，这样就不用最后再进行交替取值，空间优化到O(1)。
+
+
+# C++
+## 思路一
+``` C++
+class Solution {
+public:
+    void wiggleSort(vector<int>& nums) {
+        vector<int>tmp = nums;
+        sort(tmp.begin(), tmp.end());
+        
+        int n = nums.size();
+        int p1 = (n - 1) / 2, p2 = n - 1;
+
+        for(int i = 0; i < n; i++){
+            if(i & 1) nums[i] = tmp[p2--];
+            else nums[i] = tmp[p1--];
+        }
+    }
+};
+```
+
+## 思路二
+``` C++
+class Solution {
+public:
+    void wiggleSort(vector<int>& nums) {
+        int n = nums.size();
+        auto mid_ptr = nums.begin() + n / 2;
+        nth_element(nums.begin(), mid_ptr, nums.end());
+        int mid = *mid_ptr;
+        
+        // [0,small_right)全部小于mid
+        // (big_left, n-1]全部大于mid
+        int small_right = 0, big_left = n - 1;
+        int i = 0;
+        
+        while(i <= big_left){
+            if(nums[i] < mid) 
+                swap(nums[small_right++], nums[i++]);
+            else if(nums[i] == mid) i++;
+            else swap(nums[big_left--], nums[i]); // 这里不更新i!!!
+        }
+    
+        vector<int>tmp = nums;
+        int p1 = (n - 1) / 2, p2 = n - 1;
+        for(int i = 0; i < n; i++){
+            if(i & 1) nums[i] = tmp[p2--];
+            else nums[i] = tmp[p1--];
+        }
+    }
+};
+```
+
+## 思路二空间优化
+``` C++
+class Solution {
+public:
+    void wiggleSort(vector<int>& nums) {
+        int n = nums.size();
+        auto mid_ptr = nums.begin() + n / 2;
+        nth_element(nums.begin(), mid_ptr, nums.end());
+        int mid = *mid_ptr;
+        
+        int small_right = 0, big_left = n - 1;
+        int i = 0;
+        
+        #define A(i) nums[(2*n - 2*i - 1) % (n | 1)]
+        
+        while(i <= big_left){
+            if(A(i) < mid) 
+                swap(A(small_right++), A(i++));
+            else if(A(i) == mid) i++;
+            else swap(A(big_left--), A(i)); // 这里不更新i!!!
+        }
+    }
+};
+```