快排算法c
1、“快速排序法”使用的是递归原理，下面一个例子来说明“快速排序法”的原理。首先给出一个数组{53，12，98，63，18，72，80，46， 32，21}，先找到第一个数--53，把它作为中间值，也就是说，要把53放在一个位置，使得它左边的值比它小，右边的值比它大。{21，12，32， 46，18，53，80，72，63，98}，这样一个数组的排序就变成了两个小数组的排序--53左边的数组和53右边的数组，而这两个数组继续用同样的方式继续下去，一直到顺序完全正确。一般来说，冒泡法是程序员最先接触的排序方法，它的优点是原理简单，编程实现容易，但它的缺点就是速度太慢。
2、快速排序代码：
#include<stdio.h>
voidquicksort(inta[],intleft,intright)
{
inti,j,temp;
i=left;
j=right;
temp=a[left];
if(left>right)
return;
while(i!=j)
{
while(a[j]>=temp&&j>i)
j--;
if(j>i)
a[i++]=a[j];
while(a[i]<=temp&&j>i)
i++;
if(j>i)
a[j--]=a[i];
}
a[i]=temp;
quicksort(a,left,i-1);
quicksort(a,i+1,right);
}
voidmain()
{
inta[]={53,12,98,63,18,72,80,46,32,21};
inti;
quicksort(a,0,9);
/*排好序的结果*/
for(i=0;i<10;i++)
printf("%4d ",a[i]);
}
② C++快排的问题
下面这个答案可能对你有帮助，（不是原创）
1.稳定性比较
插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的
选择排序、希尔排序、快速排橘罩序、堆排序是不稳定的
2.时间复杂性比较
插入排序、冒泡排序、选择排序的时间复杂性为O(n2)
其它非线形排序的时间复杂性为O(nlog2n)
线形排序的时间复杂性为O(n);
3.辅助空间的比较
线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空间为O(1);
4.其它比较
插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度。反而在这种情况下，快速排序反而慢了。
当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。
若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。
当n较大时，关键字符素比较随机，对稳定性没要求宜用快速排序。
当n较大时，关键字符素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下。宜用归并排序。
当n较大时，关键字符素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。
相关知识介绍（所有定义只为帮助读者理解相关概念，并非严格定义）：
1、稳定排序和非稳定排序
简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。反之贺伍凳，就是非稳定的。比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后a1,a2,a4,a3,a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4,a2,a3,a5就不是稳定的了。
2、内排序和外排序
在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。
3、算法的时间复杂度和空间复杂度
所谓算法的时间复杂度，是指执行算法所需要的计算工作量。算法的空间复杂度，一般是指执行这个算法所需要的内存空间。
================================================
功能：选择排序
输入：数组名称（也就是数组首地址）、数组中元素个数
算法思想简单描述：
在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环
到倒数第二个数和最后一个数比较为止。
选择排序是不稳定的。算法复杂度O(n^2)--[n的平方]
================================================
功能：直接插入排序
输入：数组名称（也就是数组首地址）、数组中元素个数
算法思想简单描述：
在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排
好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数
也是排好顺序的。如此反复循环，直到全部排好顺序。
直接插入排序是稳定的。算法时间复杂度O(n^2)--[n的平方]
=====================================================
功能：冒泡排序
输入：数组名称（也就是数组首地址）、数组中元素个数
算法思想简单描述：
在要排序的一组数中，对禅旅当前还未排好序的范围内的全部数，自上
而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较
小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要
求相反时，就将它们互换。
下面是一种改进的冒泡算法，它记录了每一遍扫描后最后下沉数的
位置k，这样可以减少外层循环扫描的次数。
冒泡排序是稳定的。算法时间复杂度O(n^2)--[n的平方]
================================================
功能：希尔排序
输入：数组名称（也就是数组首地址）、数组中元素个数
算法思想简单描述：
在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，并对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。
下面的函数是一个希尔排序算法的一个实现，初次取序列的一半为增量，以后每次减半，直到增量为1。
希尔排序是不稳定的。
================================================
功能：快速排序
输入：数组名称（也就是数组首地址）、数组中起止元素的下标
算法思想简单描述：
快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟
扫描后，使得排序序列的长度能大幅度地减少。在冒泡排序中，一次
扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只
减少1。快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）
的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理
它左右两边的数，直到基准点的左右只有一个元素为止。它是由
C.A.R.Hoare于1962年提出的。显然快速排序可以用递归实现，当然也可以用栈化解递归实现。下面的函数是用递归实现的，有兴趣的朋友可以改成非递归的。
快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n^2)--[n的平方]
================================================
功能：堆排序
输入：数组名称（也就是数组首地址）、数组中元素个数
算法思想简单描述：
堆排序是一种树形选择排序，是对直接选择排序的有效改进。 堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点 的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
堆排序是不稳定的。算法时间复杂度O(nlog2n)。
③ 请哥哥姐姐为我设计个简单的快速排序算法，C语言的，谢谢啦！
void QuickSort(int *a,int left,int right)
{
if ( left < right )
{
int i = left;
int j = right + 1;//why add 1?
int pivot = a[left];//youbiao
do
{
do
{
i++;//the second
} while ( a[i] < pivot );
do
{
j--;
} while ( a[j] > pivot );
if ( i < j )
{
swap(a[i],a[j]);
}
} while ( i < j );
if (left != j)
{
swap(a[left],a[j]);
}
//digui
QuickSort(a,left,j-1);
QuickSort(a,j+1,right);
}
}
//测试排序代码
void print(int *a,int n)
{
int i;
for ( i = 0 ; i < n ; i++ )
{
printf("%d ",a[i]);
}
printf("\n");
}
int main()
{
int a[20];
myrand(a,20);
QuickSort(a,0,19);
print(a,20);
return 0 ;
}
呵呵 有问题再联系。。。。
④ 用C语言编写函数，要实现快速排序算法或者冒泡法
冒泡法排序函数如下：
void bubble(int a[],int n)
{int i,j,t;
for(i=0;i<n-1;i++)/*共进行n-1轮*/
for(j=0;j<n-1-i;j++)/*每轮在前n-i个数中比较*/
if(a[j]>a[j+1]) /*若相邻元素逆序*/
{t=a[j]; a[j]=a[j+1];a[j+1]=t;}/*就交换*/
}
void sort(int *a, int left, int right)
{
if(left >= right)/*如果左边索引大于或者等于右边的索引就代表已经整理完成一个组了*/
{
return ;
}
int i = left;
int j = right;
int key = a[left];
while(i < j) /*控制在当组内寻找一遍*/
{
while(i < j && key <= a[j])
/*而寻找结束的条件就是，1，找到一个小于或者大于key的数（大于或小于取决于你想升
序还是降序）2，没有符合条件1的，并且i与j的大小没有反转*/
{
j--;/*向前寻找*/
}
a[i] = a[j];
/*找到一个这样的数后就把它赋给前面的被拿走的i的值（如果第一次循环且key是
a[left]，那么就是给key）*/
while(i < j && key >= a[i])
/*这是i在当组内向前寻找，同上，不过注意与key的大小关系停止循环和上面相反，
因为排序思想是把数往两边扔，所以左右两边的数大小与key的关系相反*/
{
i++;
}
a[j] = a[i];
}
a[i] = key;/*当在当组内找完一遍以后就把中间数key回归*/
sort(a, left, i - 1);/*最后用同样的方式对分出来的左边的小组进行同上的做法*/
sort(a, i + 1, right);/*用同样的方式对分出来的右边的小组进行同上的做法*/
/*当然最后可能会出现很多分左右，直到每一组的i = j 为止*/
}
⑤ C语言的快速排序的算法是什么啊
快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 算法过程设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。 一趟快速排序的算法是： 1）设置两个变量I、J，排序开始的时候：I=0，J=N-1； 2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]； 3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，并与key交换； 4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，与key交换； 5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后另循环结束。) 例如：待排序的数组A的值分别是：（初始关键数据：X=49） 注意关键X永远不变，永远是和X进行比较，无论在什么位子，最后的目的就是把X放在中间，小的放前面大的放后面。 A[0] A[1] A[2] A[3] A[4] A[5] A[6]： 49 38 65 97 76 13 27 进行第一次交换后：27 38 65 97 76 13 49 ( 按照算法的第三步从后面开始找) 进行第二次交换后：27 38 49 97 76 13 65 ( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时：I=3 ) 进行第三次交换后：27 38 13 97 76 49 65 ( 按照算法的第五步将又一次执行算法的第三步从后开始找 进行第四次交换后：27 38 13 49 76 97 65 ( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时：I=4,J=6 ) 此时再执行第三步的时候就发现I=J，从而结束一趟快速排序，那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所有大于49的数全部在49的后面，所有小于49的数全部在49的前面。 快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示： 初始状态 {49 38 65 97 76 13 27} 进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65} 分别对前后两部分进行快速排序 {27 38 13} 经第三步和第四步交换后变成 {13 27 38} 完成排序。 {76 97 65} 经第三步和第四步交换后变成 {65 76 97} 完成排序。
⑥ C语言谁能告诉我 数据结构和算法里 快速排序 是怎么弄的定义两个指针，和一个关键字 具体怎么弄
快速排序是基于分治思想的排序算法。
一般的快排是把大于第一个数的放到右边，小于第一个数前陪的放到左边，然后再对带拦分成的两部分递归。
很简单的一个算法。
现在这里没有编译器，代码不好敲。如果你理解能力蠢悔胡或动手能力比较差非常需要代码的话，就追问吧~~
⑦ 快排算法每趟需要花费多少辅助空间
每趟排举袜盯序需要一个辅助空间，辅助空间和趟数有关正和，最好情况是log2n ，最差的情况是n。
快速排序由C. A. R. Hoare在1960年提出。
它的基本思想是：通过一趟排序将要排序的数据分割好碰成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
(7)快排算法c扩展阅读
一趟快速排序的算法是：
1、设置两个变量i、j，排序开始的时候：i=0，j=N-1；
2、以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
3、从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]的值交换；
4、从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]的值交换；
5、重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。
找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
⑧ 菜鸟提问 c语言关于快速排序
其实，最想说明的是那段交换的代码
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<stdio.h>
#include<stdlib.h>
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;
}
⑨ C语言，快速排序算法
0和N-1表示的是数组下标。快排每一趟排序的目的是使值比设定的key值小的数都排到数组前部分，大的都排到后部分；然后对这两部分用新的关键值key分别重复上一步的操作；递归，直到数组有序。
其中关键值key=a[low]。
用题目给定的数组模拟第一趟排序如下：
下标0123456789
值91647824661232551
low=0high=9
part_element=a[low]=9
进入for循环
进入第一个while
part_element<51，于是high--,high=8;
part_element<25，high--,high=7;
part_element>3,不满足，结束while
a[low]=a[0]=a[high]=a[7]=3,low++,low=1;
进入第二个while
part_element<16,不满足，结束while
a[high]=a[7]=a[low]=a[1]=16,high--,high=6
for第一个循环结束，数组如下
316478246612162551
low=1,high=6
for第二个循环同上，结束时数组如下
344782476612162551
low=2,high=3
for第三个循环，第一个while中high--以后，low==high，直接break跳出for循环，此时
344782476612162551
low=2,high=2
结束for以后
a[high]=a[2]=part_element=9,得到
34982476612162551
split函数returnhigh=2
quicksort函数中middle=2;
下面两句递归，仍然是调用split函数，对数组
0-2,3-9两部分分别重复上述操作
最后直到数组数据有序
⑩ 用c语言解决快速排序算法，不用递归
可以用循环代替啊。所有的递归都是可以用循环加堆栈一类的东西代替的。
但是那会比较恶心，恶心到连本人这么勤奋的好学生都不愿意写……
如果你竟然真的写了一遍，保证你写完之伍扒后这辈子不会再想写第二遍！！！
所以，劝你还是别写了吧……
其实那玩意就跟数组邻接表一样，几乎没什么用
顶多写出来跟同学显摆显摆：瞧，姐会写不用递归的快排$^_^$
我以前就曾经写过不用指针的数组邻接表，直接导致了我被大家pia飞~
而且如果你写那玩意写多了，就没人看的懂你的程序了，包括你腔乎昌自己……
（本人的数组邻接表就是例子！！！）
所以顷哪，有时间还不如去琢磨琢磨其它用处比较大的算法
另外快排这种东西我不太喜欢，代码不好写，时间复杂度未知，如果运气不好就O(n^2)了……
所以建议你改用堆排，虽然常数项大一点，但是最起码时间有保证啊！而且代码好写又好看，看着四十多行，其实翻来覆去就那几句话。写完之后如果缩进合适，远看起来特别艺术C+_+C