我想写一个用C++编写快速排序的程序，是从大到小排的，请知道尽快写给我啊，谢谢哦。。。。。。

/

快排么。网上一搜就一堆了。算法只是一种思想或说成一种方法而已，并非就C语言。其它语言也一样

快排也有点像二路归并：从一个无序的序列中随机取出一个值q做为支点,然后把大于q的放到一边，小于q的放到q的另一边,然后再以q为分界点，分别对q的两边

进行排序（快排时直接再对q两边重新取支点，整理，再取支点，直到支点两旁都有序。也就是支点两旁只有一个数时）

/

#include <stdioh>

#include <stdlibh>

int Qsort(int p[],int beg,int end)

{

if(beg+1>=end)return 0;//退出递归

int low,hight,q;

low=beg;

hight=end;

q=p[low];//q为支点，其实q可以为随机数。但相应以下程序就要改了

while(1){

while(low<hight && p[hight]>q)hight--;

if(low>=hight)break;

p[low++]=p[hight];

while(low<hight && p[low]<q)low++;

p[hight++]=p[low];

}

p[low]=q;

Qsort(p,beg,low-1);

Qsort(p,low+1,end);

}

int main()

{

int i,a[]={1,32,6,4,54,654,6,6,2,76,76,7,66,5,544,334,34,78};

Qsort(a,0,sizeof(a)/4-1);

for(i=0;i<sizeof(a)/4;i++)printf(" %d ",a[i]);

system("pause");

return 0;

}

快速排序的优势和支点元素的选择有关系。

所选支点元素每次递归后都在最前面或最后面。这样情况就会最差了。

我们知道一般的排序。（如冒泡。。）在一个数组p[m,n]中排序。都是确定最大或最小，而确定最大值（最小值）要经过n-m-1次比较。

而整个过程就差不多是(n-m-1)!次比较。

快排中：一次比较可以确定支点元素的位置。若p[m,q,n](q为支点元素）。当然确定第一个元素也是要比较（n-m-1)次。但第二个，第三个（第二层）就是(q-m-1)和(n-q-1)次比较。

明显q的值若为m或n，快排就没有什么优势了

看了LS的回答，还是我水平最高嘛……喔厚厚厚……希望采纳！鞠躬……

//希望对楼主有小小的帮助。。。

//排序的算法是二分法，N的对数时间复杂度。。。

//如果有疑问，我们可以再探讨。。。

#include<stdlibh>

#include<stringh>

#include<stdioh>

bool merge(int array,int p,int q,int r)

{

if(!(p<<q<r)&&p>=0&&r<=sizeof(array)/sizeof(array[0])-1)

{

return false;

}

int left =new int[q-p+1];

int right=new int[r-q];

memcpy(left,array+p,sizeof(int)/sizeof(char)(q-p+1));

memcpy(right,array+q+1,sizeof(int)/sizeof(char)(r-q));

int left_index=0,right_index=0,left_max_index,right_max_index;

left_max_index=q-p+1;

right_max_index=r-q;

for(int k=p;k<=r&&left_index<left_max_index&&right_index<right_max_index;++k)

{

if(left[left_index]<=right[right_index])

{

array[k]=left[left_index];

++left_index;

}

else

{

array[k]=right[right_index];

++right_index;

}

}

if(left_index==left_max_index)

{

for(;k<=r&&right_index<right_max_index;++k,++right_index)

{

array[k]=right[right_index];

}

}

else if(right_index==right_max_index)

{

for(;k<=r&&left_index<left_max_index;++k,++left_index)

{

array[k]=left[left_index];

}

}

delete left;

delete right;

return true;

}

void merge_sort(int array,int p,int r)

{

if(p<r)

{

int q=(r+p)/2;

merge_sort(array,p,q);

merge_sort(array,q+1,r);

merge(array,p,q,r);

}

}

void main()

{

int size,index, array;

//printf("请输入元素个数:");

scanf("%d",&size);

array=(int)malloc(sizesizeof(int));

for(index=0;index<size;index++)

{

//printf("请输入第%d元素:",index+1);

scanf("%d",&array[index]);

}

merge_sort(array,0,size-1);

for(index=0;index<size;index++)

{

printf("%d ",array[index]);

}

printf("\n");

}

其实，最想说明的是那段交换的代码

R[j]^=R[i];

R[i]^=R[j];

R[j]^=R[i];

一定要排除 i==j 的情况。即自己与自己交换的情况。

如：

a=9;

a^=a;/a=0/

a^=a;/a=0/

a^=a;/a=0/

a就不再是10了。

#include<stdioh>

#include<stdlibh>

void quicksort(int R[],int s,int t)

{

int i,j;

int temp;

if(s<t)

{

temp=R[s];/选第一个数作为参照/

/while(i!=j)不要用这种方法判定循环结束，万一i==j-1，i++，j--后 i〉j了，！=这个条件就救不了你了/

for(i=s+1,j=t;i<=j;i++,j--)/不包括参照数，进行左右阵营站队/

{

while(j>i && R[j]>=temp)/R[j]>=temp不要 = 也行，加了更好，毕竟相等的无论站左站右，哪边都无所谓/

j--;

while(i<j && R[i]<=temp)

i++;

if(i!=j){/i千万不能等于j/

R[j]^=R[i];

R[i]^=R[j];

R[j]^=R[i];

}

}

i--;

if(R[s]<R[i])i--;/调整i的值，使i指向最后一个小于等于参照数的位置/

/将参照数 与 最后一个小于等于参照数的数进行交换，这样就真正把左右两个阵营分开了/

R[s]=R[i];

R[i]=temp;

quicksort(R,s,i-1);

quicksort(R,i+1,t);

}

}

int main(void)

{

int i;

int a[]={5,3,2,1,9,8,7,4,5};

quicksort(a,0,sizeof(a)/sizeof(int)-1);

for(i=0;i<sizeof(a)/sizeof(int);i++)

printf("%d ",(a+i));

return 0;

}

能简短的说明一下你想要什么么，我的理解是给我一个数组，让我排序，最后输出一个从小到大（或从大到小）的数组的原数组元素下表。

比如是s[10]={21,51,12,0,61,81,91,41,71,31} 排序后a[10]={0,12,21,31,41,51,61,71,81,91}

输出为3,2,0,9,7,1,4,8,5,6对应0:s[3]=0，1:s[2]=12，2:s[0]=21，。。。。。。是这样不？

快速排序是基于分治思想的排序算法。

一般的快排是把大于第一个数的放到右边，小于第一个数的放到左边，然后再对分成的两部分递归。

很简单的一个算法。

现在这里没有编译器，代码不好敲。如果你理解能力或动手能力比较差非常需要代码的话，就追问吧~~

以上就是关于我想写一个用C++编写快速排序的程序，是从大到小排的，请知道尽快写给我啊，谢谢哦。。。。。。全部的内容，包括:我想写一个用C++编写快速排序的程序，是从大到小排的，请知道尽快写给我啊，谢谢哦。。。。。。、用C语言编写函数实现快速排序（升序），在主函数中输入数组数据,并调用该数得到排序结果。、菜鸟提问 c语言关于快速排序等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！