C语言笔记：快速排序法精讲

ゝ一纸荒年。 2023-06-07 05:43 8阅读 0赞

### 文章目录 ###

*  算法描述
 *   *  法一：左右交换法实现
     *  法二：填坑法实现（修改一下Partition1函数）
 *  快速排序的稳定性问题

# 算法描述 #

简介：快速排序法是对冒泡排序法的一种改进，因为冒泡排序法只是一端不断循环交换相邻符合条件的元素到另一端，若有n个元素，则共要循环n-1次。而在快速排序中，元素的比较和移动是从两边同时进行的。值较大的元素一次就能从前面移动到后面，值较小的元素一次就能从后面移动到前面，元素移动距离较远，减少了总的比较次数和移动次数。

下面讲的法一，法二都是基于分治法实现，先确定一个基准数（通常时第一个元素或者最后一个元素），将序列中的其他数往它两边“扔”，小于它的数都“扔”到它的左边，大于它的数都”扔“到它的右边：  
经过一趟排序后，待排序列的元素独立分割为独立的三部分，即左、中、右。此时基准元素所在的位置就是其排序后的位置（分治法）。然后左右两部分再分别重复这个操作（递归），不停的分，直到每一个分区的基准数左边以及右边最多只剩下一个数为止。

## 法一：左右交换法实现 ##

代码：

#include <stdio.h>
    #define N 8
    void QuickSort(int a[],int left,int right);//left,right分别表示待排序区间的最左下标和最右下标 
    int  Partition1(int a[],int left,int right);//划分并确定基准值 
    void Output(int a[],int n);//打印输出排序数组 
    int main(void)
    { 
     int a[N]={ 6, 2, 8, 3, 9, 1, 4, 7};
     QuickSort(a,0,N-1);//初次调用为数组a的最左下标和最右下标
     printf("\n排序后的数组为：");
     Output(a,N);
     return 0; 
    }
    void QuickSort(int a[], int left, int right)
    { 
     if(left < right)//当元素个数大于两个时，首先划分确定基准数 
     { 
      int pivot = Partition1(a, left, right);  //计算一趟排序，当前所确定的基准值所在位置
      QuickSort(a, left, pivot-1);     //基准值左边区间快速排序（a[0]~a[3]） 
      QuickSort(a, pivot+1, right);    //基准值右边区间快速排序
     }
    }
    int  Partition1(int a[],int left,int right)//左右交换法确定基准值的位置 
    { 
     int temp=a[left];//假设选取区间最左端数据作为基准值,用left记录最左端下标 
     int i=left,j=right;//然后定义两个指针（实际是整数，对应数组下标数，为便于描述说成指针）,i和j最初分别指向待排序区的最左端和最右端元素
     while(i<j)//如果i<j,即i和j不同 
     { 
      while(i<j&&a[j]>=temp)//必须是j从右向左扫描一个比基准值小的数 
      { 
       j--;
      } 
      while(i<j&&a[i]<=temp)//然后是i从左向右扫描一个比基准值大的数 
      { 
       i++;
      }
      if(i<j)//如果i和j没有相遇，则交换i和j所指的数据 
      { 
       int t=a[i];//交换i和j所指的数据 
       a[i]=a[j];
       a[j]=t;
      }
     }
     //交换 left(基准值下标) 和 i 所指的数据 
     int t = a[left];   a[left]= a[i];   a[i] = t;
        //下面为了给出各趟模拟过程
     printf("[ ");
     for(int j = left; j < i; j++)
         printf("%d ", a[j]);
     printf("] "); 
     printf("%d ", a[i]); 
     printf("[ ");
     for(int j = i + 1; j <= right; j++)
         printf("%d ", a[j]);
     printf("] \n"); 
     return i;//返回基准值在一趟排序后的下标，也是排序的最终确定下标 
    }
    void Output(int a[],int n)
    { 
     for(int i = 0; i < N; i++)
     { 
      printf("%d ", a[i]); 
     } 
     printf("\n"); 
    }

输出：  
![在这里插入图片描述][20191013105135210.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjEyNDIzNA_size_16_color_FFFFFF_t_70]

## 法二：填坑法实现（修改一下Partition1函数） ##

代码：

#include <stdio.h>
    #include <windows.h>
    #define N 8
    void QuickSort(int a[],int left,int right);//left,right分别表示待排序区间的最左下标和最右下标 
    int  Partition2(int a[],int left,int right);//分治法排序两边部分的元素 
    void Output(int a[],int n);
    void color(int m);//设置字体颜色 
    int main(void)
    { 
     int a[N]={ 6, 2, 8, 3, 9, 1, 4, 7};
     QuickSort(a,0,N-1);//初次调用为数组a的最左下标和最右下标 
     Output(a,N);
     return 0; 
    }
    void QuickSort(int a[],int left,int right)
    { 
     if(left<right)
     { 
      int pivot=Partition2(a,left,right);//计算基准值所在位置
      QuickSort(a,left,pivot-1);//基准值左边区间快速排序 
      QuickSort(a,pivot+1,right);//基准值右边区间快速排序 
     } 
    } 
    int  Partition2(int a[],int left,int right)//填坑法 
    { 
     int temp=a[left];//临时存放基准值（默认每趟排序的最左边元素） ,填坑法会覆盖原来的基准值 
     int i=left,j=right;
     while(i<j)//左右下标移动的前提是左、右下标i,j不同 
     { 
      while(i<j&&a[j]>=temp)//必须是j从右向左扫描找一个比基准值小的数 
      { 
       j--;
      } 
      if(i<j)
      { 
       a[i]=a[j];//将a[j]放入坑中，新的坑是下标j处 
      } 
      while(i<j&&a[i]<=temp)//然后再是i从左向右扫描找一个比基准值大的数 
      { 
       i++;
      }
      if(i<j)
      { 
       a[j]=a[i];//将a[i]放入坑中，新的坑是下标i处 
      } 
     }
     a[i]=temp; 
     //下面给出各趟排序的模拟过程
     printf("[ ");
     for(int j=left;j<i;j++)
     { 
      printf("%d ",a[j]);
     }
     printf("] ");
     color(0xC);
     printf("%d ",a[i]);
     color(0x7);
     printf("[ ");
     for(int j=i+1;j<=right;j++)
     { 
      printf("%d ",a[j]);
     }
     printf("] \n");
     return i;//返回一趟排序后，当前设置的基准值的下标 
    } 
    void Output(int a[],int n)
    { 
     printf("最终排序结果：");
     for(int i = 0; i < N; i++)
     { 
      printf("%d ", a[i]); 
     } 
     printf("\n"); 
    }
    void color(int m) 
    { 
     HANDLE consolehend;
     consolehend = GetStdHandle(STD_OUTPUT_HANDLE);//获取控制台缓冲区句柄
     SetConsoleTextAttribute(consolehend, m);//参数一为控制台缓冲区句柄，参数二为要设置的颜色
    }

输出：  
![在这里插入图片描述][20191013094037209.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjEyNDIzNA_size_16_color_FFFFFF_t_70 1]

# 快速排序的稳定性问题 #

快速排序法是一个非常优秀且比较常用的排序方法，尤其适合大量的数据排序，但数据较少或数据正序或者逆序时，这种方法反而不快速了。

稳定性情况：  
假设有两个相同的元素r\[i\]和r\[j\]（i<j），它们都比最初选定的基准值小，在挖坑法中，r\[j\]是右移指针j第一次遇到的比基准值小的数，r\[j\]填入到基准值所在坑（现在在最左边，本来r\[j\]在r\[i\]右边），此时r\[j\]移动到r\[i\]前面，故快速排序是不稳定的

[20191013105135210.png]: /images/20230601/2ea45d0176b54a7dbc96d561b931a898.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjEyNDIzNA_size_16_color_FFFFFF_t_70]: /images/20230601/8bc3ec4f49054cb68545fc4055db737c.png
[20191013094037209.png]: /images/20230601/63da755d4d4f410491ddd9c109a3de12.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjEyNDIzNA_size_16_color_FFFFFF_t_70 1]: /images/20230601/39fed625be6c4d1ca6c5339cfaa1cc9c.png