“快速排序法”

// QuickSort.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

//“快速排序法”使用的是递归原理，
//下面我结合一个例子来说明“快速排序法”的原理。
//首先给出一个数组{53，12，98，63，18，72，80，46， 32，21}，
//先找到第一个数--53，把它作为中间值，
//也就是说，要把53放在一个位置，使得它左边的值比它小，
//右边的值比它大。{21，12，32， 46，18，53，80，72，63，98}，
//这样一个数组的排序就变成了两个小数组的排序--53左边的数组和53右边的数组，
//而这两个数组继续用同样的方式继续下去，一直到顺序完全正确。

//我这样讲你们是不是很胡涂，不要紧，我下面给出实现的两个函数：

/*
n就是需要排序的数组，left和right是你需要排序的左界和右界，
如果要排序上面那个数组，那么left和right分别是0和9
*/
void swap(int& a,int& b);
int partition(int n[],int left,int right);
int partitionNew(int n[],int left,int right);
void quicksort(int n[], int left,int right);
void quicksortNew(int n[], int left,int right);
void swap(int& a,int& b)
{
	int tmp;
	tmp=a;
	a=b;
	b=tmp;
}

void quicksortNew(int n[], int left,int right)
{
int dp;
int step=right-left;
if(step<=0)return;
else if(step==1)
{
	if(n[left]>n[right])
		swap(n[left],n[right]);
	return;
}
else{

     /*
     这就是下面要讲到的函数，按照上面所说的，就是把所有小于53的数放
     到它的左边，大的放在右边，然后返回53在整理过的数组中的位置。
     */
     dp=partitionNew(n,left,right);

     quicksortNew(n,left,dp-1);

     quicksortNew(n,dp+1,right); //这两个就是递归调用，分别整理53左边的数组和右边的数组
}
}


//我们上面提到先定位第一个数，
//然后整理这个数组，把比这个数小的放到它的左边，大的放右边，然后
//返回这中间值的位置，下面这函数就是做这个的。
int partitionNew(int n[],int left,int right)
{
/*
int lo,hi,pivot,t;

pivot=n[left];
lo=left;
hi=right+1;

while(lo+1!=hi) {
     if(n[lo+1]<=pivot)
       lo++;
     else if(n[hi-1]>pivot)
       hi--;
     else {
       //t=n[lo+1];
       //n[++lo]=n[hi-1];
       //n[--hi]=t;
		 swap(n[++lo],n[--hi]);
     }
}

//n[left]=n[lo];
//n[lo]=pivot;
swap(n[left],n[lo]);
return lo;
//*/

//*
int lo;
lo=left;
int hi=right+1;
while(lo!=hi-1){
	if(n[lo+1]<=n[left])
	{
	  lo++;
	  
	}
	else if(n[hi-1]>n[left])
	{
	   hi--;
	  
	}
	else
	{
		swap(n[++lo],n[--hi]);
	}
}

swap(n[lo],n[left]);
return lo;//<=>return hi
//*/
}

void printArry(int arry[],int n)
{
	for(int i=0;i<n;i++)
		printf("%d ",arry[i]);
	printf("\n");
}
void main()
{
	int arry[]={1,2,9,8,7,6,5,0};
	int n=sizeof(arry)/sizeof(int);
	quicksort(arry, 0,n-1);
	printArry(arry,n);

	int arryNew[]={1,2,9,8,7,6,5,0};
	n=sizeof(arryNew)/sizeof(int);
	quicksortNew(arryNew, 0,n-1);
	printArry(arryNew,n);

}
/*
     这段程序并不难，应该很好看懂，我把过程大致讲一下，
	 首先你的脑子里先浮现一个数组和三个指针，
	 第一个指针称为p指针，在整个过程结束之前它牢牢的指向第一个数，
	 第二个指针和第三个指针分别为lo指针和hi指针，
	 分别指向最左边的值和最右边的值。
	 lo指针和hi指针从两边同时向中间逼近，
	 在逼近的过程中不停的与p指针的值比较，
	 如果lo指针的值比p指针的值小，
	 lo++，还小还++，再小再++，
	 直到碰到一个大于p指针的值，暂时等待...
	 这时视线转移到hi指针，
	 如果 hi指针的值比p指针的值大，hi--，还大还--，再大再--，
	 直到碰到一个小于p指针的值。
	 这时就把lo指针的值和hi指针的值做一个调换。【等待结束:)】
	 
	   持续这过程直到两个指针碰面，
	   这时把p指针的值和碰面的值做一个调换，
	   然后返回p指针新的位置。 
*/
/*
n就是需要排序的数组，left和right是你需要排序的左界和右界，
如果要排序上面那个数组，那么left和right分别是0和9
*/

void quicksort(int n[], int left,int right)
{
int dp;
if (left<right) {

     /*
     这就是下面要讲到的函数，按照上面所说的，就是把所有小于53的数放
     到它的左边，大的放在右边，然后返回53在整理过的数组中的位置。
     */
     dp=partition(n,left,right);

     quicksort(n,left,dp-1);

     quicksort(n,dp+1,right); //这两个就是递归调用，分别整理53左边的数组和右边的数组
}
}

int partition(int n[],int left,int right)
{
int lo,hi,pivot,t;

pivot=n[left];
//lo=left-1;
lo=left;
hi=right+1;

while(lo+1!=hi) {
     if(n[lo+1]<=pivot)
       lo++;
     else if(n[hi-1]>pivot)
       hi--;
     else {
       t=n[lo+1];
       n[++lo]=n[hi-1];
       n[--hi]=t;
     }
}

n[left]=n[lo];
n[lo]=pivot;
return lo;
}