快速排序
设计思路:
1.交换式-快速排序
a)判断数组元素个数,如果数组元素个数小于等于1,无需对数组进行排序,直接返回;
b)若数组元素个数大于1,将数组的最右边的元素作为本次排序的基准值;
c)定义俩个下标值,一个为开始位置下标left,另一个为最终位置下标right;
d)保证left<right的前提下,从前到后通过改变left值,查找一个大于基准值的元素 ,找到后停止本次查找 ;
e)保证left<right的前提下,从后到前查找一个小于基准值的元素,找到后停止本次查找;
f)若left的值不等于right的值,将两次查找的值进行交换;
g)若left的值等于right的值,将基准值与left处的值进行交换,在分别对left的左右俩边进行上述操作;
h)操作结束后,现数组就是一个有序数组。
2.挖坑式-快速排序
a)判断数组元素个数,如果数组元素个数小于等于1,无需进行排序,直接返回;
b)若数组元素个数大于1,将数组的最右边的元素作为本次排序的基准值;
c)先定义一个value用来保存基准值;
d)再定义两个下标,一个下标为left是指定数据的开始下标,另一个为right是指定数据的结束下标;
e)在left<right的前提下,从前到后通过改变left值查找到一个大于基准值的元素,将该元素赋值于基准值所在下标所指元素;
f)在left<right的前提下,从后到前通过改变right值找到一个小于基准值的元素,将该元素赋值于下标为left所指元素;
g)反复执行e、f操作,直到left 值等于right值,将value值赋值于下标为left所指元素,对left左右两边的元素进行上述操作;
h)操作结束,先数组就是一个有序数组。
3.非递归快速排序
本质上,非递归快速排序就是通过栈来代替递归所要完成的操作
a)将传入数组的0值入栈,再将传入数组的size-1值入栈;
b)进行循环,对栈进行取栈顶元素,如果栈顶元素为空,表示排序结束;
c)若栈顶元素不为NULL,定义俩个变量beg与end,然后对连续取栈顶元素赋值与beg与end,调用交换式排序对所得数组进行排序,将返回值赋值与mid;
d)将beg、mid、mid+1,end依次入站,本次循环结束,进入下一次循环,直到栈为空,数组就成为了一个有序数组。
交换式-快速函数程序代码:
int64_t Partion(int array[],int64_t beg,int64_t end){
if(end - beg<=1){
return beg;
}
int64_t left = beg;
int64_t right = end -1;
int key = array[right];
while(left <right){
while(left<right&&array[left] <key){
++left;
}
while(left<right&&array[right]>key){
--right;
}
if(left<right){
swap(&array[left],&array[right]);
}
}
swap(&array[left],&key);
return left;
}
void _QuickSort1(int array[],int64_t beg,int64_t end){
if(end-beg <=1){
return;
}
int64_t mid = Partion(array,beg,end);
_QuickSort1(array,beg,mid);
_QuickSort1(array,mid,end);
return;
}
//交换法快速排序函数实现
void QuickSort1(int array[],int64_t size){
_QuickSort1(array,0,size);
return;
挖坑式-快速函数程序代码:
//QuickSort函数
void QuickSort(RecType arr[],int start,int tail){
int i = start;
int j = tail;
RecType tmp = arr[i];
if(i<j){
while(i!=j){
while(j>i&&arr[j] > tmp){//从右向左找到第一个小于tmp的值
--j;
}
arr[i] = arr[j];
while(i<j && arr[i] < tmp){//从左向右找到第一个大于tmp的值
++i;
}
arr[j] = arr[i];
}
arr[i] = tmp;
QuickSort(arr,start,i-1);//对左区间递归排序
QuickSort(arr,i+1,tail);//对右区间递归排序
}
}
非递归版本-快速函数程序代码:
//非递归版本快速排序
void QuickSortByLoop(int array[],int64_t size){
if(size<= 1){
return;
}
SeqStack seq;
SeqStackInit(&seq);
int64_t beg = 0;
int64_t end = size;
SeqStackPush(&seq,beg);
SeqStackPush(&seq,end);
while(1){
int ret = GetStackTop(&seq,&end);
if(ret == 0){
//栈为空
return;
}
SeqStackPop(&seq,&end);
GetStackTop(&seq,&beg);
SeqStackPop(&seq,&beg);
if(end - beg <= 1){
continue;
}
int64_t mid = Partion(array,beg,end);
SeqStackPush(&seq,beg);
SeqStackPush(&seq,mid);
SeqStackPush(&seq,mid+1);
SeqStackPush(&seq,end);
}
return;
}
测试用例程序代码(仅显示交换式快速排序 的测试用例,其他俩种较为相似):
//检测函数
void TestQuickSort(){
int array[] = {1,3,9,2,6,4};
int64_t size = sizeof(array)/sizeof(array[0]);
int i = 0;
for(;i<size;++i){
printf("%d ",array[i]);
}
printf("\n");
QuickSort1(array,size);
i = 0;
for(;i<size;++i){
printf("%d ",array[i]);
}
printf("\n");
return;
}
//主函数
int main(){
TestQuickSort();
return 0;
}
检测结果显示(仅对交换式-快速排序结果进行显示):