#include stdlib.h
创新互联建站是一家专注于网站设计制作、成都做网站与策划设计,香格里拉网站建设哪家好?创新互联建站做网站,专注于网站建设十年,网设计领域的专业建站公司;建站业务涵盖:香格里拉等地区。香格里拉做网站价格咨询:13518219792
#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
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
冒泡法排序函数如下：
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 为止*/
}
给个快速排序你参考参考
/********************** 快速排序 ****************************
基本思想：在待排序的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); // 递归对高子表递归排序
}
}
你好！
首先 0 ，n-1 。应该是 数组的坐标（因为n个数字。所以数组的坐标是0 到n-1）
而a是你传入的数组。所以他会根据数组的坐标到数组中找到元素。比较并进行排序。
递归这段理解如下：
首先要了解快速排序的思想：
1）随意找一个基准数 。将比基准小的都放到它左边。比它大的都放到它右边。所以当返回基准的坐标的时候。其实这个坐标左边都是小于它的，右边都是大于等于它的。（这里主要是看代码的实现。图中代码是大于等于在右边。也可以自己写小于等于在左边。这个不影响最后结果）
2）那么第二次对于返回基准坐标的左右两边。我们同样利用返回的基准坐标找到两个“基准”（如下图）。就会使得返回的这两个基准左右两边有序
第三次 用返回的两个基准找到四个基准（如图）
然后不断递归..不断的在整体有序的情况下使局部变的有序。
假设 为 532348789
第一次以a【0】 5为基准 。
则：
图中红色标识为基准元素 最后会使得数组全局有序。
希望能对你有所帮助。
快速排序（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的值，6549,两者交换，此时：I=3 ) 进行第三次交换后：27 38 13 97 76 49 65 ( 按照算法的第五步将又一次执行算法的第三步从后开始找 进行第四次交换后：27 38 13 49 76 97 65 ( 按照算法的第四步从前面开始找大于X的值，9749,两者交换，此时：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} 完成排序。