快速排序

快速排序

算法思想：

快速排序的算法思想：选区一个关键字，通过一趟排序将一组数据划分为两部分，其中一部分比所选取的关键字小（放到关键字左边），另一部分比所选取的关键字大（放到关键字右边）。利用分治的思想对其中每一个部分在进行一趟这样的排序，直至达到最终有序。

实现原理：

1、设置两个变量low=0，high=n-1

2、进行第一趟划分，将基准值放到正确的位置，是的小的元素在左边，大的元素在右边：

      1）选取第一个元素作为基准值。base=array[low]

      2)  因为默认选取第一个元素作为基准值，因此应该先从后向前进行搜索，通过high--，向前移动找到第一个小于base的元素array[high],将这个元素array[high]赋给array[low]。（循环条件base<=array[high],循环结束时,base>array[high]）

      3)  此时开始从前向后搜索，通过low++，向后移动找到第一个大于base的元素array[low],将这元素array[low]赋给array[high]，即array[high]=array[low]，（循环条件是array[low]<=base,循环结束时base<array[low]）

      4)  循环2）3）步骤直至low=high时，该位置就是基准位置。

      5）将基准值base放到基准位置。

3、利用分治思想对基准两边进行同样的划分策略。

举例演示：

例如随机给出一组数据：array[8]={ 5 , 7 , 2 , 4 , 9 , 1 , 3 , 4 }，选取第一个元素5作为基准值base=5。做需要先从后向前比较

1、进行第一趟划分：base=5

      5 7 2 4 9 1 3 4    low=0,high=7,base>array[7]，交换。

      4 7 2 4 9 1 3 5    low=0，high=7，base>array[low],不交换，low++。low=1，比较，交换。

      4 5 2 4 9 1 3 7    low=1，high=7，base<array[high]，不交换，high--。low=1，high=6,5>3,交换。

      4 3 2 4 9 1 5 7    low=1，high=6，base>array[low],不交换，low++。low=2，low++。low=3，不换，low++，low=4，交换。

      4 3 2 4 5 1 9 7    low=4,high=6，base<array[high],不换，high--。high=5，交换。

      4 3 2 4 1 5 7 9    low=4,high=5,不换，low++。low=high=5。退出循环。

代码实现：

#include<iostream>
#include<cstdlib>
using namespace std;

int partition(int array[], int i, int j)
{
    int base = array[i];//选取第一个元素为基准值 
    while(i < j)
    {
        //因为基准值是第一个元素，所以应该从最后一个元素开始比较。
        while(i < j && base <= array[j])
        {
            j--;
        } 
        //当找到一个比基准值小的元素时，将这个元素与基准值“交换”。 
        if(i < j)
        {
            array[i] = array[j];
        }
        //开始从前边找一个比基准值大的元素 
        while(i < j && array[i] <= base)
        {
            i++;
        }
        //找到之后，将这个元素放后，“交换” 
        if(i < j)
        {
            array[j] = array[i]; 
        }
    }
    /*
    上边交换是一个假的交换，因为基准值最终都要回到他应该取得位置，
    当退出循环时，i=j，此时，该位置就是基准值应该所在的正确位置。 
    */
    //把基准值放到正确的位置
    array[i] = base;
    //同时需要返回i值，利用分治思想，可以利用i值，对i左边的部分分别进行同样的划分。 
    return i;
}

void QuickSort(int array[] , int low , int high)
{
    //当元素只有一个时，不需要排序，作为递归的出口。
    if(low < high)
    {
        int temp = partition(array, low, high);
        
        QuickSort(array, low, temp - 1);
        QuickSort(array, temp + 1, high);
    } 
}

void show(int array[], int size)
{
    for(int i = 0; i < size; i++)
    {
        cout << array[i] << " ";
    }
    cout << "\n"; 
}
int main()
{
    int array[] = {3,6,1,4,7,3,5,2,9,0}; 
    int size = sizeof(array) / sizeof(int);
    cout << size << endl;
    QuickSort(array, 0, size-1);
    show(array, size);
    
    size = 20;
    int arr_1[20] = {0};
    for(int i = 0; i < 10; i++)
    {
        for(int j = 0; j < size; j++)
        {
            arr_1[j] = rand() % 1000;//随机生成数组 
        }
        //排序前的数组
        cout << "排序前的数组："; 
        show(arr_1, size);
        QuickSort(arr_1, 0, size-1);
        cout << "排序后的数组：";
        show(arr_1, size);
    }
    
    return 0;
}