数据结构之快速排序

• 
  只有比别人更早、更勤奋地努力，才能尝到成功的滋味

       快速排序算法是冒泡排序算法的改进，与冒泡排序类似，快速排序也是通过交换逆序元素来进行排序的。不同的是，冒泡排序的交换是相邻的，而且快速排序一次交换就可以消除多个逆序元素。

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

首先对于一无序数组a：50,30,20,65,44,85,60,55（并将其编号为0-7,）；

我们首先需要选定一个关键字pivotkey = a[0]=50；

然后将这个关键字与这个数组两端的数相比较，并逐渐往中间搜索。

最好用动手在纸上推导一番就很容易了(ﾉ*･ω･)ﾉ

排序流程：

1、首先a[high]=a[7]=55>pivotkey=50;所以我们不需要变动a[7]的数字，然后使得high--；

2、再用a[6]与pivotkey比较；由于a[6]=60>pivotkey=50,所以我们不需要变动a[6]的数字，然后使得high--；

3、此时high=5;所以再用a[5]与pivotkey比较；由于a[5]=85>pivotkey=50,所以我们不需要变动a[5]的数字，然后使得high--；

4、此时high=4;所以再用a[4]与pivotkey比较；由于a[4]=44<pivotkey=50,所以我们需要交换a[4]与a[low]的两个数，因为此时low=0；所以交换后a[4]=50;a[0]=44;

5、这个时候要看a[low]端开始与pivotkey进行比较，首先a[low]=a[0]=44<pivotkey=50;所以我们不需要变动a[0]的数字，然后使得low++；

6、再用a[1]与pivotkey比较；由于a[1]=30<pivotkey=50,所以我们不需要变动a[1]的数字，然后使得low++；

7、此时low=2;所以再用a[2]与pivotkey比较；所以我们不需要变动a[1]的数字，然后使得low++；

8、此时low=3;所以再用a[3]与pivotkey比较由于a[3]=65>pivotkey=50,所以我们需要交换a[3]与a[high]的两个数，因为此时high=4；所以交换后a[4]=65;a[3]=50;

9、再次循环，由于a[3]<a[4],执行上述1-8后，得到low=high=3;

10、可以得到第一轮排序结果为 {44,30,20,}50,{65,85,60,55}，可以得到两个部分，再分别进行上述操作，就可以得到最终结果。

程序如下：

#include <stdio.h>
#include <stdlib.h>

void swap(int *a,int *b)
{
    int tmp;
    tmp=*a;
    *a=*b;
    *b=tmp;
}
int partition(int a[],int low,int high)
{
    int i;
    int pivotkey=a[low];
    while(low<high)
    {
        while(low<high&&a[high]>=pivotkey)
            high--;
        swap(&a[low],&a[high]);
        while(low<high&&a[low]<=pivotkey)
            low++;
        swap(&a[low],&a[high]);
    }
    printf("\n");
    for(i=0; i<8; i++)
        printf("%4d",a[i]);
    printf("\n");
    return low;
}
void QuickSort(int a[],int low,int high)
{
    int pivot;
    if(low<high)
    {
        pivot=partition(a,low,high);
        QuickSort(a,low,pivot-1);   //关键点左边的部分
        QuickSort(a,pivot+1,high);  //关键点左边的部分
    }
}
int main()
{
    int i;
    int a[8]= {50,30,20,65,44,85,60,55};
    QuickSort(a,0,7);
      printf("\n最终排序结果为：");
    for(i=0; i<8; i++)
        printf("%4d",a[i]);
    return 0;
}

结果：

2、根据输入整型数组和排序标识，对其元素按照升序或降序进行排序

#include<iostream>
#include<algorithm>
#include<vector>
#include<string>

using namespace std;


//bool compUp(int a, int b)
//{
//    return a < b;   //升序排列，如果改为return a>b，则为降序
//}
//
//bool compDown(int a, int b)
//{
//    return a > b;
//}
void quickSortUp(vector<int> &arr,int l,int h)
{
    int low = l;
    int high = h;
    int key = arr[low];
    if(low<high)
    {
        while(low<high)
        {
            while(low<high&&arr[high]>=key)
            {
                high--;
            }
            arr[low] = arr[high];
            while(low<high&&arr[low]<=key)
            {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = key;
        quickSortUp(arr,l,low-1);
        quickSortUp(arr,low+1,h);
    }
}
void quickSortDown(vector<int> &arr,int l,int h)
{
    int low = l;
    int high = h;
    int key = arr[low];
    if(low<high)
    {
        while(low<high)
        {
            while(low<high&&arr[high]<=key)
            {
                high--;
            }
            arr[low] = arr[high];
            while(low<high&&arr[low]>=key)
            {
                low++;
            }
            arr[high] = arr[low];
        }
        arr[low] = key;
        quickSortDown(arr,l,low-1);
        quickSortDown(arr,low+1,h);
    }
}
void sortArray(vector<int> intArray,int flagSort)
{
    int len = intArray.size();
    int low = 0;
    int high = len-1;
    /*快排*/
    if(flagSort == 0)
        quickSortUp(intArray,low,high);
    else
    {
        quickSortDown(intArray,low,high);
    }
    /*冒泡*/
//    if(flagSort==0)
//    {
//        for(int i=0; i<len-1; i++)
//        {
//            for(int j=i+1; j<len; j++)
//            {
//
//
//                if(intArray[j]<intArray[i])
//                {
//                    int temp = intArray[j];
//                    intArray[j] = intArray[i];
//                    intArray[i] = temp;
//                }
//            }
//        }
//    }
//    else
//    {
//        for(int i=0; i<len-1; i++)
//        {
//            for(int j=i+1; j<len; j++)
//            {
//                if(intArray[j]>intArray[i])
//                {
//                    int temp = intArray[j];
//                    intArray[j] = intArray[i];
//                    intArray[i] = temp;
//                }
//            }
//        }
//    }
    /*sort函数调用*/
//    if(flagSort==0)
//    {
//        sort(intArray.begin(), intArray.end(), compUp);
//    }
//    else
//    {
//        sort(intArray.begin(), intArray.end(), compDown);
//    }
    for(int i=0; i<len-1; i++)
    {
        cout<<intArray[i]<<" ";
    }
    cout<<intArray[len-1]<<endl;
}
int main()
{
    int n;
    while(cin>>n)
    {
        int flagSort = 0;
        vector<int> integerArray;
        integerArray.clear();
        for(int i=0; i<n; i++)
        {
            int temp;
            cin>>temp;
            integerArray.push_back(temp);
        }
        cin>>flagSort;   //0：升序，1：降序
        sortArray(integerArray,flagSort);
    }
    return 0;
}