C++ 快速排序
#include <iostream>
using namespace std;
/*
//注意,该函数是以最后一个元素p[end]为pivot。
QuickSort(int p[], int start, int end)
{
if (start >= end) //(1)此时无需排序,所以返回。(2).1 这还保证了,如果只有2个元素时,j=end-1 =1>0
return;
int i = start, j = end - 1;
int tmp;
do
{
while(p[i]<p[end]){i++;}
while(p[j]>=p[end]){j--;} //(4) 解决相等元素问题。
if (i<j)
swap(p[i], p[j]);
else
swap(p[i], p[end]);//确定pivot的准确位置。
}
while(i < j);
//(3)至此完成了一趟快速排序得到:小于pivot的数 | pivot | 大于等于pivot的数
QuickSort(p, start, i-1); //对小于pivot的数进行快速排序。
QuickSort(p, i+1, end); //对大于等于pivot的数进行快速排序。
//(2).2 如果i到end时,即end前的所有元素都小于pivot,会发现,i+1>end了,即递归调用时会立刻返回,所以不会发生p[i]操作越界的现象,因为根本就没机会往下走。(2).3同理。
}
void PrintArrary(int data[], int size)
{
for (int i=0; i<size; ++i)
{
cout <<data[i]<<" ";
}
cout<<endl;
}
int main(int argc, const char** argv)
{
int array[]= {20,34,4,53,43,42,6,67,193};
int size = sizeof(array)/sizeof(int);
QuickSort(array, 0, size - 1);
PrintArrary(array, size);
return 0;
}
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//输出数组函数
void out_int_array(int data[], int n)
{
int i;
for(i = 0; i < n; i++)
{
printf("%d ", data[i]);
}
printf("\n");
}
//交换函数
void swap(int *a, int *b)
{
int x;
x = *a;
*a = *b;
*b = x;
}
//由于总是选择数组的最后一个元素做为轴,因此可能出现X的左边为n - 1或接近n - 1个元素,
//而右边没有元素,或元素很少的情况,即X最大或比较大。这样使quicksort将出现最坏的情况,
//也就是时间复杂度为O(n^2)。因此partition可以采用随机方式得到轴X的位置i。
//这样它的平均情况是非常好的(时间复杂度为O(nlogn)),也就是说,最坏情况很难出现。
//生成随机数
int new_random(int min, int max)
{
return (min + (int)(((float)rand()/RAND_MAX)*(max - min)));
}
// 其中partition函数将得到X所在的位置i(在这里总以数组的最后一个元素为轴)。
int partition(int A[], int p, int r)
{
int i = p - 1, j;//p为数组开头,r为数组的末尾
for(j = p; j < r; j++)
{
if(A[j] >= A[r])
{
i++;
swap(&A[i], &A[j]);
}
}
swap(&A[i + 1], &A[r]);
return i + 1;
}
void quicksort(int A[], int p, int r)
{
int i;
if(p < r)
{
i = partition(A, p, r);
quicksort(A, 0, i - 1);
quicksort(A, i + 1, r);
}
}
int randomize_partition(int A[], int p, int r)
{
int i = new_random(p, r);
swap(&A[i], &A[r]);
return partition(A, p, r);
}
void randomize_quicksort(int A[], int p, int r)
{
int i;
if(p < r)
{
i = randomize_partition(A, p, r);
quicksort(A, 0, i - 1);
quicksort(A, i + 1, r);
}
}
int main()
{
int A[] = {4, 1, 44, -12, 5, 125, 30};
int B[] = {4, 1, 44, -12, 5, 125, 30};
out_int_array(A, 7);
quicksort(A, 0, 6);
out_int_array(A, 7);
printf("--------------------------randomize-----------------------------\n");
srand((unsigned)time( NULL ));
randomize_quicksort(B, 0, 6);
out_int_array(B, 7);
return 0;
}
using namespace std;
/*
//注意,该函数是以最后一个元素p[end]为pivot。
QuickSort(int p[], int start, int end)
{
if (start >= end) //(1)此时无需排序,所以返回。(2).1 这还保证了,如果只有2个元素时,j=end-1 =1>0
return;
int i = start, j = end - 1;
int tmp;
do
{
while(p[i]<p[end]){i++;}
while(p[j]>=p[end]){j--;} //(4) 解决相等元素问题。
if (i<j)
swap(p[i], p[j]);
else
swap(p[i], p[end]);//确定pivot的准确位置。
}
while(i < j);
//(3)至此完成了一趟快速排序得到:小于pivot的数 | pivot | 大于等于pivot的数
QuickSort(p, start, i-1); //对小于pivot的数进行快速排序。
QuickSort(p, i+1, end); //对大于等于pivot的数进行快速排序。
//(2).2 如果i到end时,即end前的所有元素都小于pivot,会发现,i+1>end了,即递归调用时会立刻返回,所以不会发生p[i]操作越界的现象,因为根本就没机会往下走。(2).3同理。
}
void PrintArrary(int data[], int size)
{
for (int i=0; i<size; ++i)
{
cout <<data[i]<<" ";
}
cout<<endl;
}
int main(int argc, const char** argv)
{
int array[]= {20,34,4,53,43,42,6,67,193};
int size = sizeof(array)/sizeof(int);
QuickSort(array, 0, size - 1);
PrintArrary(array, size);
return 0;
}
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//输出数组函数
void out_int_array(int data[], int n)
{
int i;
for(i = 0; i < n; i++)
{
printf("%d ", data[i]);
}
printf("\n");
}
//交换函数
void swap(int *a, int *b)
{
int x;
x = *a;
*a = *b;
*b = x;
}
//由于总是选择数组的最后一个元素做为轴,因此可能出现X的左边为n - 1或接近n - 1个元素,
//而右边没有元素,或元素很少的情况,即X最大或比较大。这样使quicksort将出现最坏的情况,
//也就是时间复杂度为O(n^2)。因此partition可以采用随机方式得到轴X的位置i。
//这样它的平均情况是非常好的(时间复杂度为O(nlogn)),也就是说,最坏情况很难出现。
//生成随机数
int new_random(int min, int max)
{
return (min + (int)(((float)rand()/RAND_MAX)*(max - min)));
}
// 其中partition函数将得到X所在的位置i(在这里总以数组的最后一个元素为轴)。
int partition(int A[], int p, int r)
{
int i = p - 1, j;//p为数组开头,r为数组的末尾
for(j = p; j < r; j++)
{
if(A[j] >= A[r])
{
i++;
swap(&A[i], &A[j]);
}
}
swap(&A[i + 1], &A[r]);
return i + 1;
}
void quicksort(int A[], int p, int r)
{
int i;
if(p < r)
{
i = partition(A, p, r);
quicksort(A, 0, i - 1);
quicksort(A, i + 1, r);
}
}
int randomize_partition(int A[], int p, int r)
{
int i = new_random(p, r);
swap(&A[i], &A[r]);
return partition(A, p, r);
}
void randomize_quicksort(int A[], int p, int r)
{
int i;
if(p < r)
{
i = randomize_partition(A, p, r);
quicksort(A, 0, i - 1);
quicksort(A, i + 1, r);
}
}
int main()
{
int A[] = {4, 1, 44, -12, 5, 125, 30};
int B[] = {4, 1, 44, -12, 5, 125, 30};
out_int_array(A, 7);
quicksort(A, 0, 6);
out_int_array(A, 7);
printf("--------------------------randomize-----------------------------\n");
srand((unsigned)time( NULL ));
randomize_quicksort(B, 0, 6);
out_int_array(B, 7);
return 0;
}