给个快速排序你参考参考
我们提供的服务有：网站设计、成都网站建设、微信公众号开发、网站优化、网站认证、歙县ssl等。为成百上千企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的歙县网站制作公司
/********************** 快速排序 ****************************
基本思想：在待排序的n个记录中任取一个记录（通常取第一个记录），
以该记录为基准，将当前的无序区划分为左右两个较小的无
序子区，使左边的记录均小于基准值，右边的记录均大于或
等于基准值，基准值位于两个无序区的中间位置（即该记录
最终的排序位置）。之后，分别对两个无序区进行上述的划
分过程，直到无序区所有记录都排序完毕。
*************************************************************/
/*************************************************************
函数名称：static void swap(int *a, int *b)
参 数：int *a---整型指针
int *b---整型指针
功 能：交换两个整数的位置
返 回 值：无
说 明：static关键字指明了该函数只能在本文件中使用
**************************************************************/
static void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
int quickSortNum = 0; // 快速排序算法所需的趟数
/*************************************************************
函数名称：static int partition(int a[], int low, int high)
参 数：int a[]---待排序的数据
int low---无序区的下限值
int high---无序区的上限值
功 能：完成一趟快速排序
返 回 值：基准值的最终排序位置
说 明：static关键字指明了该函数只能在本文件中使用
**************************************************************/
static int partition(int a[], int low, int high)
{
int privotKey = a[low]; //基准元素
while(low high)
{ //从表的两端交替地向中间扫描
while(low high a[high] = privotKey) // 找到第一个小于privotKey的值
high--; //从high所指位置向前搜索，至多到low+1位置
swap(a[low], a[high]); // 将比基准元素小的交换到低端
while(low high a[low] = privotKey) // 找到第一个大于privotKey的值
low++; //从low所指位置向后搜索，至多到high-1位置
swap(a[low], a[high]); // 将比基准元素大的交换到高端
}
quickSortNum++; // 快速排序趟数加1
return low; // 返回基准值所在的位置
}
/*************************************************************
函数名称：void QuickSort(int a[], int low, int high)
参 数：int a[]---待排序的数据
int low---无序区的下限值
int high---无序区的上限值
功 能：完成快速排序算法，并将排序完成的数据存放在数组a中
返 回 值：无
说 明：使用递归方式完成
**************************************************************/
void QuickSort(int a[], int low, int high)
{
if(low high)
{
int privotLoc = partition(a, low, high); // 将表一分为二
QuickSort(a, low, privotLoc-1); // 递归对低子表递归排序
QuickSort(a, privotLoc+1, high); // 递归对高子表递归排序
}
}
1、冒泡排序（最常用）
冒泡排序是最简单的排序方法：原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。（注意每一轮都是从a[0]开始比较的）
以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。
2、鸡尾酒排序
鸡尾酒排序又称双向冒泡排序、鸡尾酒搅拌排序、搅拌排序、涟漪排序、来回排序或快乐小时排序, 是冒泡排序的一种变形。该算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序。
原理：数组中的数字本是无规律的排放，先找到最小的数字，把他放到第一位，然后找到最大的数字放到最后一位。然后再找到第二小的数字放到第二位，再找到第二大的数字放到倒数第二位。以此类推，直到完成排序。
3、选择排序
思路是设有10个元素a[1]-a[10]，将a[1]与a[2]-a[10]比较，若a[1]比a[2]-a[10]都小，则不进行交换。若a[2]-a[10]中有一个以上比a[1]小，则将其中最大的一个与a[1]交换，此时a[1]就存放了10个数中最小的一个。同理，第二轮拿a[2]与a[3]-a[10]比较，a[2]存放a[2]-a[10]中最小的数，以此类推。
4、插入排序
插入排序是在一个已经有序的小序列的基础上，一次插入一个元素*
一般来说，插入排序都采用in-place在数组上实现。
具体算法描述如下：
⒈ 从第一个元素开始，该元素可以认为已经被排序
⒉ 取出下一个元素，在已经排序的元素序列中从后向前扫描
⒊ 如果该元素（已排序）大于新元素，将该元素移到下一位置
⒋ 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
⒌ 将新元素插入到下一位置中
⒍ 重复步骤2~5
#include stdlib.h
#include stdio.h
#define MAXN 8
#define MOD 1024
void QuickSort(int *arr, int low, int high)
{
if (low = high) return;
//保存排序区间的 起始位置和终点位置
int left = low, right = high;
//默认 左边第一个元素 为标志
int key = arr[low];
while (low high)
{
while (low high arr[high] = key) --high;
arr[low] = arr[high];
while (low high arr[low] = key) ++low;
arr[high] = arr[low];
}
arr[low] = key;
//每次排序后都分成两部分[left, low) (low, right]
//arr[low]的位置是一定是有序的
QuickSort(arr, left, low - 1);
QuickSort(arr, low + 1, right);
return;
}
int main(void)
{
int n;
scanf("%d", n);
int arr[MAXN] = {0};
int i;
for (i = 0; i n; ++i)
scanf("%d", arr[i]);
//输入是默认为生活中习惯的数组左边第一个为：编号1
int s, m;
scanf("%d %d", s, m);
//转成计算机数组第一个为：编号0
s--; m--;
//快排
QuickSort(arr, s, m);
//输出
for (i = s; i = m; ++i)
{
printf("%d ", arr[i]);
}
return 0;
}
//测试数据
//8
//1 2 3 4 5 6 7 8
//2 6
输出 6 5 4 3 2
#include stdio.h
#includestdlib.h
#includestring.h
int comp(char *a,char *b)
{
while(*a==*b*a*b){a++;b++;}
return (int)*a-(int)*b;
}
int main(void)
{
char s[1000][20];
int i,n;
scanf("%d\n",n);
for(i=0;in;i++)
gets(s[i]);
qsort(s,n,sizeof(s[0]),comp);
printf("\n");
for(i=0;in;i++)
puts(s[i]);
system("pause");
return 0;
}
冒泡法排序函数如下：
void bubble(int a[],int n)
{int i,j,t;
for(i=0;in-1;i++)/*共进行n-1轮*/
for(j=0;jn-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 为止*/
}
函数kuaipai1 进入了无限死循环。
递归函数没有一个节点判定递归结束，导致进入死循环
系统堆栈用完，程序崩溃。
程序调试报告有无限死循环危险，运行后就直接崩溃，导致栈溢出。