说明：使用递归及非递归两种方式实现快速排序

    1. 排序数组
      给你一个整数数组 nums，请你将该数组升序排列。

    示例 1：
    输入：nums = [5,2,3,1]
    输出：[1,2,3,5]
    示例 2：
    输入：nums = [5,1,1,2,0,0]
    输出：[0,0,1,1,2,5]

    提示：
    1 <= nums.length <= 50000
    -50000 <= nums[i] <= 50000

    1. class Solution {
    2. public:
    3.     vector<int> sortArray(vector<int>& nums) {
    4.         quickSort2(nums);
    5.         return nums;
    6.     }
    8.     // 递归版本
    9.     void quickSort1(vector<int>& nums, int start, int end) {
    10.         if (start >= end) {
    11.             return;
    12.         }
    14.         int mid = nums[start];
    15.         int left = start, right = end;
    16.         while (left < right) {
    17.             while (left < right && nums[right] >= mid) --right;
    18.             nums[left] = nums[right];
    19.             while (left < right && nums[left] <= mid) ++left;
    20.             nums[right] = nums[left];
    21.         }
    23.         nums[left] = mid;
    24.         quickSort1(nums, start, left - 1);
    25.         quickSort1(nums, left + 1, end);
    26.     }
    28.     // 非递归版本
    29.     void quickSort2(vector<int>& nums) {
    30.         stack<int> st;
    31.         st.push(0);
    32.         st.push(nums.size() - 1);
    33.         int start = 0, end = 0;
    34.         while(!st.empty()) {
    35.             int end = st.top();
    36.             st.pop();
    37.             int start = st.top();
    38.             st.pop();
    40.             int mid = nums[start];
    41.             int left = start, right = end;
    42.             while (left < right) {
    43.                 while (left < right && nums[right] >= mid) --right;
    44.                 nums[left] = nums[right];
    45.                 while (left < right && nums[left] <= mid) ++left;
    46.                 nums[right] = nums[left];
    47.             }
    49.             nums[left] = mid;
    50.             if (start < left - 1) {
    51.                 st.push(start);
    52.                 st.push(left - 1);
    53.             }
    55.             if (left + 1 < end) {
    56.                 st.push(left + 1);
    57.                 st.push(end);
    58.             }
    59.         }
    60.     }
    61. };

    用时：33min，但是这两种快排写法在大数组的测试case都超时了。。。继续研究一下为什么。