本文目录一览：
C语言中快速排序法的原理及应用
“快速排序法”使用的是递归原理，下面我结合一个例子来说明“快速排序法”的原理。首先给出一个数组{53，12，98，63，18，72，80，46， 32，21}，先找到第一个数--53，把它作为中间值，也就是说，要把53放在一个位置，使得它左边的值比它小，右边的值比它大。{21，12，32， 46，18，53，80，72，63，98}，这样一个数组的排序就变成了两个小数组的排序--53左边的数组和53右边的数组，而这两个数组继续用同样的方式继续下去，一直到顺序完全正确。 一般来说，冒泡法是程序员最先接触的排序方法，它的优点是原理简单，编程实现容易，但它的缺点就是--程序的大忌--速度太慢。 附上快速排序代码：
#include<stdio.h>
void quicksort(int a[], int left, int right) {
int i, j, temp;
i = left;
j = right;
temp = a[left];
if (left >= right)
return;
while (i != j) {
while (a[j] >= temp && i < j)
j--;
if (i < j)
a[i++] = a[j];
while (a[i] <= temp && i < j)
i++;
if (i < j)
a[j--] = a[i];
}
a[i] = temp;
quicksort(a, left, i - 1);
quicksort(a, i + 1, right);
}
void main() {
int a[] = {53, 12, 98, 63, 18, 72, 80, 46, 32, 21};
int i;
quicksort(a, 0, 9);
/*排好序的结果*/
for (i = 0; i < 10; i++)
printf("%4d\n", a[i]);
}
关于快速排序C语言算法
//一点小问题而已，已为你改好
#include <stdio.h>
void Quick_sort(int s[], int l, int r) {
if (l < r) {
int i = l, j = r, x = s[l];
while (i < j) {
while (i < j && s[j] >= x)
j--; //从右向左找第一个小于x的数
if (i < j)
s[i++] = s[j];
while (i < j && s[i] <= x)
i++; //从左到右找第一个大于等于x的数
if (i < j)
s[j--] = s[i];
}
s[i] = x;
Quick_sort(s, l, i - 1); //递归
Quick_sort(s, i + 1, r);
}
}
int main() {
int arr[7] = {1, 9, 7, 6, 5, 35, 15};
int i;
printf("之前的数组：");
for (i = 0; i < 7; i++)
printf("%3d", arr[i]);
printf("\n");
Quick_sort(arr, 0, 6);
printf("排序之后的数组：");
for (i = 0; i < 7; i++)
printf("%3d", arr[i]);
printf("\n");
return 0;
}
c语言怎样实现快速排序
#include<stdio.h>
int arr_num[7];
int length;
void quick_sort(int left, int right) {
int i, j, c, temp;
if (left >= right)
return;
i = left;
j = right;
temp = arr_num[i];
while (i != j) {
while (arr_num[j] >= temp && i < j)
j--;
while (arr_num[i] <= temp && i < j)
i++;
if (i < j) {
c = arr_num[i];
arr_num[i] = arr_num[j];
arr_num[j] = c;
}
}
// left为起始值（参照值）此时的I为第一次排序结束的最后值，与参照值交换位置
arr_num[left] = arr_num[i];
arr_num[i] = temp;
//继续递归直到排序完成
quick_sort(left, i - 1);
quick_sort(i + 1, right);
}
int main() {
int i;
length = 7;
arr_num[7] = {23, 7, 17, 36, 3, 61, 49};
//快速排序调用
quick_sort(0, length - 1);
//输出排序后的结果
for (i = 1; i <= length; i++)
printf("%d ", arr_num[i]);
getchar();
getchar();
return 0;
}
C语言快速排序代码
采用快速排序，用递归实现
#include <stdio.h>
#define N 10 //定义排序数组元素个数
int Qsort(int start, int length, int a[]) //start排序的起始，length是要排序序列长度
{
int x = a[start];
int i, j;
i = start;
j = length - 1;
while (i < j) {
if (x < a[j])
j--;
else if (x > a[j]) {
a[i] = a[j];
a[j] = x;
i++;
} else if (x > a[i]) {
a[j] = a[i];
a[i] = x;
j--;
} else
i++;
}
if (start < length - 1) {
Qsort(start, i, a);
Qsort(i + 1, length, a);
}
}
void main() {
int a[N] = {0};
int i;
for (i = 0; i < N; i++)
scanf("%d", &a[i]);
Qsort(0, N, a);
for (i = 0; i < N; i++)
printf("%d ", a[i]);
}
程序执行时输入N个数，对这N个数进行排序，可以预设N的长度。
谁有快速排序的C语言实现啊
#include <stdio.h>
typedef int InfoType;
#define n 10 //假设的文件长度，即待排序的记录数目
typedef int KeyType; //假设的关键字类型
typedef struct { //记录类型
KeyType key; //关键字项
InfoType otherinfo; //其它数据项，类型InfoType依赖于具体应用而定义
} RecType;
typedef RecType SeqList[n + 1]; //SeqList为顺序表类型，表中第0个单元一般用作哨兵
int Partition(SeqList R, int i, int j);
void main() {
void QuickSort(SeqList R, int low, int high);
int i;
SeqList R;
printf("请输入欲排序的10个数：");
for (i = 1; i <= n; i++)
scanf("%d", &R[i].key);
printf("排序前：");
for (i = 1; i <= n; i++)
printf("%d ", R[i].key);
printf("\n");
QuickSort(R, 1, n);
printf("排序后：");
for (i = 1; i <= n; i++)
printf("%d ", R[i].key);
printf("\n");
}
void QuickSort(SeqList R, int low, int high) { //对R[low..high]快速排序
int pivotpos; //划分后的基准记录的位置
if (low < high) { //仅当区间长度大于1时才须排序
pivotpos = Partition(R, low, high); //对R[low..high]做划分
QuickSort(R, low, pivotpos - 1); //对左区间递归排序
QuickSort(R, pivotpos + 1, high); //对右区间递归排序
}
}
int Partition(SeqList R, int i, int j) { //调用Partition(R,low,high)时，对R[low..high]做划分，并返回基准记录的位置
RecType pivot = R[i]; //用区间的第1个记录作为基准
while (i < j) { //用区间两端交替向中间扫描，直至i=j为止
while (i < j && R[j].key >= pivot.key) //pivot相当于在位置i上
j--; //从右向左扫描，查找第1个关键字小于pivot.key的记录R[j]
if (i < j) //表示找到的R[j]的关键字<pivot.key
R[i++] = R[j]; //相当于交换R[i]和R[j]，交换后i指针加1
while (i < j && R[i].key <= pivot.key) //pivot相当于在位置j上
i++; //从左向右扫描，查找第1个关键字大于pivot.key的记录R[i]
if (i < j) //表示找到了R[i]，使R[i].key> pivot.key
R[j--] = R[i]; //相当于交换R[i]和R[j]，交换后j指针减1
}
R[i] = pivot; //基准记录已被最后定位
return i;
}
用C语言编程实现快速排序算法
给个快速排序你参考参考
/********************** 快速排序 ****************************
基本思想：在待排序的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); // 递归对高子表递归排序
}
}
