排序算法-快速排序

quick sorting(快速排序)

**理论：**在一组需要被排序的数中，以第一个数位基数，将小与它的数排它左边，大于它的数排右边，这样给这个基数排好位置，左边又是一组数，右边是一组数，再对每组数单独进行相同的操作，一直递归下去，具体看图

比如说我需要对这十个数进行排序，左边 "小兵（i）"刚开始站在基数上，右边 "小兵（j）"开始向左找，找比6小的数，找到就在那停下。

接着左边 "小兵（i）"开始向右找比6大的数，找到就停下，然后两个进行交换

交换之后如下

然后 j 继续左移找比6小的数，在4处停下来，然后 i继续右移找比6大的数，在9处停下来，交换


接着j继续左移，在3停了，i 右移在3处碰到 j

这时候将 i 和 j 碰到的数字与基数(6)交换

这样一轮就结束了，接着对  “6左边的数” “6右边的数”  进行相同的操作，递归下去。

具体实现

#include "stdafx.h"
#include "iostream"
using namespace std;

int a[100];
void quick_sorting(int a[], int length)
{
   if (length <= 1) return;
	int i = 0, j = length - 1;
	int ch, tmp;
	
	tmp = a[0];
	while (i != j)
	{
		while (a[j] >= tmp && j > i)
		{
			j--;
		}

		while (a[i] <= tmp && i < j)
		{
			i++;
		}

		if (i < j)
		{
			ch = a[i];
			a[i] = a[j];
			a[j] = ch;
		}

	  }
		     ch = a[0];
			a[0] = a[i];
			a[i] = ch;
		
		
		
	quick_sorting(&a[0], i);
	quick_sorting(&a[i + 1], length - i -1);
	return;
}

}



int main()
{
	int i;

	for(i=0;i<10;i++)//input
	cin >> a[i];

	quick_sorting(a,10);//sorting


	for (i = 0; i < 10; i++)//output
		cout << a[i]<< " ";

    return 0;
}

结果

---

方法二

• 快排的核心：随机找一个数，进行操作得到结果：左边都是比它小，右边都是比它大；然后再递归地对它左右进行相同操作

#include <iostream>
using namespace std;

void Swap(int* a, int* b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

//找一个值，左边比它小，右边比它大，返回此值的index
int Partition(int data[], int length, int start, int end)
{
    if(data == NULL || length <=0 || start<0 || end>=length || end<0)
	return -1;

    // 选择start 作为中间
    int mid = start;
    for(int index=start+1; index<=end; ++index)// 遍历数组,和start比较
    {
	if(data[index] < data[start]) 
	{
	    ++ mid;
	    if(mid != index) // 证明上次或者连续好几次的数 > start, 但是这次 data[index] < data[start] , [mid index) 之间都是比start大的数
		Swap(&data[mid], &data[index]);
	}
    } //结束遍历之后，data[mid] <= data[start]

    Swap(&data[mid], &data[start]);
    return mid;
}


void QuickSorting(int data[], int length, int start, int end)
{
    if(data==NULL || length<=0) return;
    if(start == end) return;


    int index = Partition(data, length, start, end);
    if(index > start)
	QuickSorting(data, length, 0, index-1);
    if(index < end)
	QuickSorting(data, length, index+1, end);
}




void Test1(void)
{
    int data[] = {1};
    int length = sizeof(data)/sizeof(int);
    QuickSorting(data, length, 0, length-1);
    if(data[0] == 1)
	cout << "Test1 passed" << endl;
}


void Test2(void)
{
    int data[] = {1, 2, 3, 4, 5};
    int length = sizeof(data)/sizeof(int);
    QuickSorting(data, length, 0, length-1);
    for(int i=1; i<=5; i++)
    {
	if(data[i-1] != i)
	    return;
    }
	cout << "Test2 passed" << endl;
}

void Test3(void)
{
    int data[] = {};
    int length = sizeof(data)/sizeof(int);
    QuickSorting(data, length, 0, length-1);
    cout << "Test3 passed" << endl; //如果没出现异常
}

void Test4(void)
{
    int data[] = {2, 22,431,5365,3,365};
    int length = sizeof(data)/sizeof(int);
    QuickSorting(data, length, 0, length-1);
    if(data[0] != 2) return;
    if(data[1] != 3) return;
    if(data[2] != 22) return;
    if(data[3] != 365) return;
    if(data[4] != 431) return;
    if(data[5] != 5365) return;

    cout << "Test4 passed" << endl;  
}



int main(int argc, char** argv)
{

    Test1();
    Test2();
    Test3();
    Test4();

    return 0;
}

结果：

结论 ：时间复杂度O(N*logN),最差的情况就是已经排好的序列进行排序，时间复杂度和冒泡法一样 O($N^2$)