数据结构之庖丁解牛八大排序算法，附动图和源码（快排－中Ａ）

目录

3.2快速排序

a.Hoare法

b.挖坑法：

c.前后指针法

---

3.2快速排序

本文主要将快排的递归方法，非递归方法见下节。

        快速排序是Hoare提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中的所有元素小于基准值，右子序列中所有元素均大于基准值，然后左右子序列重复该过程，直到所有元素排列在相应位置上位置。

        快速排序有三种方法：Hoare法，挖坑法，前后指针法，下面我们详解这三种方法

a.Hoare法

假设有如下序列：

先看单趟，假设此时键值key指向6,left指向6，right指向8，此时先从右找，找到比key值小停止，再从左找，找到比6大的停止，然后交换两个数。

为什么要让right先走？ 这是因为要保证left和right相遇的时候的位置，要比key小。left和right相遇：一种是right停住，L遇到R，相遇的位置就是R停住的位置；一种是left停住，R遇到L，停住的位置就是L停住的位置

实现代码如下:

int left = 0, right = n-1;
int key = a[left];

//先看实现单趟
while(left <right)
{    while(a[right] > a[key])
    {
        --right;
    }

    while(a[left] < a[key])
    {
        ++left;
    }

Swap(&a[left],a[right]);

}

Swap(&a[left],&key);

上述的错误集锦展示很容易踩坑，修改代码如下:

//错误集锦展示

void QuickSort(int * a, int n)
{
    int left = 0; right = n-1;
    int key = a[left];
    while(left <right)
    {
        while(a[right] >key)           // 如果右边所有的值都比key大，--right会造成right越界
        {
            --right;                  
        }
        
        while(a[left] < key)          //如果左边所有值都比key小，++left也会造成left越界
        {
            ++left;
        }
        
        Swap(&a[left],&a[right]);
    }
        
    Swap(&a[left],&a[right]);

    }

    Swap(&a[left],&key);         // 交换a[left]和key ，此时key对应的只是一个值，并没有变化，当第二次快排的时候，key已经变化，所以需要找的是key的下标

}
void QuickSort(int * a, int n)
{
    int left = 0 ,right = n-1;
    ine key = a[left];
    while(left <right)
    {
        while(left < right && a[right] >= key)
        {
            --right;
        }
        
        while(left <right && a[left] <= key)
        {
            ++left;
        }

        
        Swap(&a[left],&a[right])
    }

    Swap(&a[left], key i)

}

上述的方法只是实现了单趟，分割出了左右子序列，然后要对左右子序列进行快排，先看使用递归的方法。使用begin,end,key定位这个序列，begin指向0,end指向n-1,key先指向begin的位置。实现代码如下:

void QucikSort(int * a , int begin, int end)
{
    if(begin>= end)
        return;
    
    int left = begin ,right = end;
    int keyi = left;
    while(left <right)
    {
        //右边先走，找小
        while(left <right && a[right] >= a[keyi])
        {
            --right;
        }
    
        while(left <right && a[left] <= a[keyi])
        {
            ++left;
        }
        
        Swap(&a[left],&a[right]);
    }
    
    Swap(&a[left],&a[keyi]);
    //此时已经划分出了第一个区间
    keyi = left;
    //[begin,keyi-1],keyi,[keyi+1,end]

    QucikSort(a,begin,keyi-1);
    QucikSort(a,keyi+1,end);
}

此时有一个更改进的方法，如果key值选择不好，就会影响这个排序的快慢，所以采用一个三数取中的方法，同时，在区间很小的时候，再使用递归，此时再去开辟函数的栈帧，有一些杀鸡用宰牛刀的意思，可以使用直接插入的方法进行优化实现代码如下。

首先看三数取中，需要两两之间进行比较，实现代码如下：

int GetMidIndex(int * a, int begin ,int end)
{
    int mid = (begin + end) /2;
    
    if(a[begin] < a[mid])
    {
        if(a[begin] < a[end])
            return begin;
        else
            return end;
    }
    else
    {
        if(a[begin] >a[end])
            return end;
        else
            return begin;
    }
}


void QucikSort(int * a, int n)
{
    if(begin >= end)
        return;
    //如果区间较小，直接选择插入排序
    if( (end -begin +1 ) < 10 )
        InsertSort(a+begin, end-begin+1);
    else
    {
        int mid = GetMidIndex(a,begin,end);
        Swap(&a[begin],&a[mid]);

        int left = begin,right = end;
        int keyi = left;
        while(left <right)
        {
            //右边先走，找小
            while(left<right && a[right]>=a[keyi])
            {
                --right;
            }

            //左边再走
            while(left <right && a[left] <=a[keyi])
            {
                ++left;
             }
            
            Swap(&a[left],&a[right]);
        }
    
        Swap(&a[left],&a[keyi];
        keyi = left;

        //[begin,keyi-1] ,keyi,[keyi+1,right]
        QuickSort(a,begin,keyi-1);
        QuickSort(a,keyi+1,end);
    }
}

b.挖坑法：

挖坑法的思想是，先将第一个数据存放在临时变量k中，形成一个坑位，然后R往右走，找比基准值小的，放在坑中，此时这个R原来指的位置为坑，L往右走，找比基准值大的，放在坑中，一直到L，R相遇，将k中的值放到坑里，此时这个坑就是我们要找的keyi，左边序列比key小，右边序列都比key大，再去递归这两个区间，相当于一种二叉树前序遍历的方法。实现的代码如下:

int PartSort2(int * a, int begin, int end)
{
    int left = begin , right = end;

    //如果想改进，此处的hole也可以使用三数取中找到基准值
    //int hole = GetMidIndex(a,begin,end);
    int hole = left;
    
    while(left <right)
    {
        while(left <right && a[right] >= a[hole])
        {
            --right;
        }
        
        //右边找到了比hole小的数，放在坑里，右边形成新的坑
        a[hole] = a[right];
        hole = right;
        
        wwhile)left <right && a[left]<= a[hole])
        {
            ++left;
        }
        
        //左边找到了比left大的数，放在坑里,形成新的坑
        a[hole] = a[left];
        hole = left;
    
   }
    //当left和right相遇，把key值放进来
    a[hole] = key;
    return hole;
}

//再去快排递归
void QucikSort(int * a, int begin, int end)
{
    int left = begin, right = end
    int keyi = PartSort2(a,begin,end);
    QuickSort(a,begin,keyi-1);
    QuickSort(a,keyi+1,end);
}