C语言快速排序代码

Posted 2023-05-07

输入n(个数）,a[]
能运行的
要能运行的，调通了再拿来，好了加分

采用快速排序，用递归实现
#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的长度 参考技术A #include <stdio.h>

int partions(int l[],int low,int high)

int prvotkey=l[low];
l[0]=l[low];
while (low<high)

while (low<high&&l[high]>=prvotkey)
--high;
l[low]=l[high];
while (low<high&&l[low]<=prvotkey)
++low;
l[high]=l[low];


l[low]=l[0];
return low;


void qsort(int l[],int low,int high)

int prvotloc;
if(low<high)

prvotloc=partions(l,low,high); //将第一次排序的结果作为枢轴
qsort(l,low,prvotloc-1); //递归调用排序 由low 到prvotloc-1
qsort(l,prvotloc+1,high); //递归调用排序 由 prvotloc+1到 high




void quicksort(int l[],int n)

qsort(l,1,n); //第一个作为枢轴 ，从第一个排到第n个


void main()

int a[11]=0,2,32,43,23,45,36,57,14,27,39;

for (int b=1;b<11;b++)
printf("%3d",a[b]);

printf("\n");
quicksort(a,11);

for(int c=1;c<11;c++)
printf("%3d",a[c]);

本回答被提问者和网友采纳 参考技术B 推荐回答中的程序有些不妥，改后的程序为
#include <stdio.h>
int partions(int l[],int low,int high)

int prvotkey=l[low];
while (low<high)

while (low<high&&l[high]>=prvotkey)
--high;
if (low<high)
l[low++]=l[high];
while (low<high&&l[low]<=prvotkey)
++low;
if (low<high)
l[high--]=l[low];

l[low]=prvotkey;
return low;

void qsort(int l[],int low,int high)

int prvotloc;
if(low<high)

prvotloc=partions(l,low,high); //将第一次排序的结果作为枢轴
qsort(l,low,prvotloc-1); //递归调用排序 由low 到prvotloc-1
qsort(l,prvotloc+1,high); //递归调用排序 由 prvotloc+1到 high

return;

void quicksort(int l[],int n)

qsort(l,0,n-1); //第一个作为枢轴 ，从第一个排到第n个
return;

void main()

int a[11]=0,2,32,43,23,45,36,57,14,27,39;
for (int b=0;b<11;b++)
printf("%3d",a[b]);
printf("\n");
quicksort(a,11);
for(int c=0;c<11;c++)
printf("%3d",a[c]);

这个程序是可用的，大家可以试试 参考技术C 快速排序，递归实现，短小精干版：
#include<stdio.h>
#include<stdlib.h>
void quickSort(int* arr,int startPos, int endPos)

int i,j;
int key;
key=arr[startPos];
i=startPos;
j=endPos;
while(i<j)

while(arr[j]>=key && i<j)--j;
arr[i]=arr[j];
while(arr[i]<=key && i<j)++i;
arr[j]=arr[i];

arr[i]=key;
if(i-1>startPos) quickSort(arr,startPos,i-1);
if(endPos>i+1) quickSort(arr,i+1,endPos);


int main()

int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
quickSort(a,0,9);
for(i=0;i<10;i++)
printf("%d ",a[i]);
printf("\n");
system("pause");
return 0;
参考技术D #include <stdio.h>
#define N 10
main()

int i, j, temp;
int a[N];
printf("please input %d numbers:\n",N);
for(i = 0; i < N; i++)

scanf("%d",&a[i]);


for (i = 0; i < N-1; i++) //表示要比较N-1趟

for (j =0; j < N-i-1; j++) //表示每趟比较的次数

if (a[j] > a[j+1])

temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;



for(i = 0; i < N; i++)

printf("%-5d",a[i]);

printf("\n");

快速排序 + 代码实现（C语言）

快速排序过程分析

(1)首先设定一个分界值key，一般使用数组第一个元素，通过该分界值将数组分成左右两部分。

(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边 。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。

(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。

重复上述过程，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

代码实现

#include <stdio.h>

//快速排序函数 分别传入数组、左边索引、右边索引
void quickSort(int a[], int left, int right) {
    int i = left, j = right,key,t;
    if (left >= right) return; //如果左边索引大于或者等于右边的索引直接退出
    key = a[left];
    while (i < j) {
        while (a[j] >= key && i < j) j--; //该循环完成后a[j] < pk
        while (a[i] <= key && i < j) i++; //该循环完成后a[i] > pk
        // 两个while结束的时候a[i]>a[j]
        if(i < j) {
            t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    } //while结束的时候i=j
    a[left] = a[i];
    a[i] = key;
    quickSort(a, left, i - 1);
    quickSort(a, i+1, right);
}

//打印输出函数
void display(int array[],int length) {
    for (int i = 0; i < length; i++) {
        printf("%d \\n",array[i]);
    }
}

// 主函数
int main()
{
    int array[] = {12,85,25,16,34,23};
    quickSort(array, 0, 5);
    //sizeof(array) ：数组总长度，sizeof(array[0])：数组单个元素长度。做除法求得了数组元素个数
    display(array,sizeof(array) / sizeof(array[0]));
    return 0;
}

运行结果
12 
16 
23 
25 
34 
85