简洁的快速排序

快速排序相信大家都知道了，这里带给大家一个简洁的快速排序代码。

快速排序的实质是分治（分而治之）。

 void my_qsort(int* arr, int left, int right)
 {
     if (left >= right)    // left == right 也可以，看个人的习惯吧。
         return;
     
     // 边界的设置
     int target = arr[left], prev = left - 1, cur = right + 1; 
        // 用do while 循环的时候用的（先加先减）
     //int target = arr[left], prev = left, cur = right;       
        // 如果用 while 循环的时候可以用

     // 双指针从前后找
     while (prev < cur)
     {
         //while (arr[prev] < target)     // 
         //{
         //    prev++;
         //}
         //while (arr[cur] > target)
         //{
         //    cur--;
         //}
  
         do
         {
             prev++;
         } while (arr[prev] < target);
         do
         {
             cur--;
         } while (arr[cur] > target);
 
         if (prev < cur)     // 因为这里有判断 prev < cur,所以前面的while括号里面不用加了
         {
             int temp = arr[prev];
             arr[prev] = arr[cur];
             arr[cur] = temp;
         }
     }
     
     // 递归
     my_qsort(arr, left, cur);  // 如果用的是my_qsort(arr, left, prev - 1); 都是对称的
     my_qsort(arr, cur + 1, right);  
        // my_qsort(arr, prev, right); 也可以不过前面的target = arr[prev + cur + 1] / 2;
 }
 

左右指针一次交换的示意图： 

 

对于do while循环的先加加，先减减的解释： 

// 先加加，因为前面初始化 prev 的时候 prev = left - 1; 来到了 prev = left 的位置进行判断；

// 先减减，因为前面初始化 cur 的时候 cur = right + 1; 来到了 cur = right 的位置进行判断；

来一个牛客编程题练练手，对比对比看看这里的代码是不是简洁的：

https://www.nowcoder.com/practice/2baf799ea0594abd974d37139de27896 

 

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 * 将给定数组排序
 * @param arr int整型一维数组 待排序的数组
 * @param arrLen int arr数组长度
 * @return int整型一维数组
 * @return int* returnSize 返回数组行数
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 */

void my_qsort(int* q, int left, int right)    
{
    if (left >= right) return;

    int x = q[left], i = left - 1, j = right + 1;    
    while (i < j)
    {
        do
        {
           i++;                             
        } while (q[i] < x);
        do
        {
           j--;                              
        } while (q[j] > x);

        if (i < j)
        {
            int temp = q[i];
            q[i] = q[j];
            q[j] = temp;
        }
    }

    my_qsort(q, left, j);      
    my_qsort(q, j + 1, right); 
}

int* MySort(int* arr, int arrLen, int* returnSize ) 
{
    my_qsort(arr, 0, arrLen - 1);
    *returnSize = arrLen;
    return arr;
}

​

1.  当然，有用递归。如果递归的深度太大，函数列表里面的参数变量存储在栈里面会溢出。

2.  但是快速排序说是快速排序，总体性能还是很好的哈。

3.  时间复杂度相信那么都知道，这里就不说了。

4.  快速排序也是可以不用递归写的，但是这里追求的是“简洁”。

5.  这里因为是把数组左边的数都交换变成了 <= target 的，数组右边的数都交换变成 >= target 的了。这个算法是不稳定的算法，当然数组里面 等于 target 的数的相对位置还是没有变化的，因为我这里等于的情况是不做交换的，左右两边是可以有相等的数的。

6.  稳不稳定看的是原来相等数字的相对位置在排序之后的相对位置是否变化。