C语言 QUICKSORT排序 升序变降序

合集下载

c语言sort函数

c语言sort函数

c语言sort函数c语言中的sort函数是一种用于对数组进行排序的函数。

它使用的是一种称为“快速排序”的算法,这种算法是一种基于比较的排序算法,具有较高的效率和性能。

sort函数的声明如下:```c```参数解释:- base: 指向要排序的数组的指针。

- nitems: 数组中的元素个数。

- size: 每个元素的字节数。

sort函数使用递归的方式进行排序,其基本思想是选择一个基准元素,将数组分为左右两部分,左边的元素小于等于基准元素,右边的元素大于等于基准元素,然后对左右两部分递归调用sort函数,直到每个部分只有一个元素为止。

在这个排序算法中,我们需要传入一个比较函数,该函数用于比较两个元素的大小。

比较函数应该返回一个整数值,当第一个元素小于第二个元素时返回负数,当两个元素相等时返回0,当第一个元素大于第二个元素时返回正数。

根据比较结果,sort函数将适当地调整元素的位置,以实现排序的目的。

下面是一个使用sort函数对一个整型数组进行升序排序的示例:```c#include <stdio.h>#include <stdlib.h>return (*(int*)a - *(int*)b);int maiint arr[] = {5, 2, 8, 6, 3, 1, 7, 9, 4};int n = sizeof(arr) / sizeof(arr[0]);printf("升序排序后的数组:");for (int i = 0; i < n; i++)printf("%d ", arr[i]);}return 0;```输出结果为:123456789,表示数组已经按照升序排列完成。

```creturn strcmp(*(char**)a, *(char**)b);```sort函数是标准库函数,很多C语言开发环境都提供了该函数的实现。

快速排序(C语言)

快速排序(C语言)

快速排序(C语言)快速排序是冒泡排序的一种改进,主要的算法思想是在待排序的n个数据中取第一个数据作为基准值,将所有记录分为3组,使第1组中各数据值均小于或等于基准值,第2组做基准值的数据,第3组中各数据均大于或等于基准值。

快速排序是排序算法中,平均时间复杂度为O(n*logn)的一种算法,其实现需要先解决这样的一个问题,对一个序列A[1],A[2],A[3].......A[N],调整序列中元素的位置,使得A[1](原序列中的第一个元素,下同)的左侧所有元素都不超过A[1],右侧所有元素都大于A[1],例如对序列{5,3,9,6,4,1}来说,调整后变为{3,1,4,5,9,6}这样就让A[1]=5,左侧的所有元素,不超过它,右侧的所有元素都大于它。

排序思想1.快排是对冒泡排序的一种改进,在快速排序中,元素的比较和移动是从两端向中间进行的,关键码较大的元素一次就能从前面移动到后面,关键码较小的元素一次就能从后面移动到前面,元素移动距离的较远,从而减少了总的比较次数和移动次数2.快速排序是基于分治法设计的,其分治策略是:①、划分:选定一个元素作为轴值,以轴值为基准将整个序列划分为两个子序列。

轴值的位置在划分的过程中确定,并且前一个子序列的元素均小于或者等于轴值,后一个子序列的元素大于或者等于轴值②、求解子问题:分别对划分后的每一个子序列递归处理③、合并:由于对子序列的排序是就地进行的,所以合并并不需要执行任何操作排序方法1.选择轴值,一般是选取第一个元素的关键码。

有一个快排的最坏情况就是如果待排序元素是正序或者逆序,就会将除轴值以外的元素分到轴值的一边。

2.划分①、设置划分区间:i=first,j=end②、执行右侧扫描,直到r[j]小于轴值,将r[j]与r[i]交换,i++③、执行左侧扫描,直到r[i]大于轴值,将r[i]与r[j]交换,j–④、重复二到三直到i=j,确定看轴值的所在位置,返回该位置。

快速排序c语言

快速排序c语言

快速排序c语言首先我们要对一组数据进行排序:1.在数组中选一个基准数(通常为数组第一个,黄圈圈标记了);2.将数组中小于基准数的数据移到基准数左边,大于基准数的移到右边,怎么移动,后面说;3.对于参考号左右两侧的数组,连续重复上述两个过程,直到每个子集只有一个元素,即全部有序。

好了,咱们开始吧!快速排序需要两个哨兵,i 和 j,分别指向数组的头和尾。

接下来就要进行移动。

我们通常选择第一个元素作为基准数,去移动数组元素,使其达到这个基准数的左边都是小于它的,右边都是大于它的。

开始移动 i 和 j , i 和 j 是交互移动的,这里我们需要先移动 j,这是为甚呢,原因是先移动 j,等到这一行移动结束,i 的下一个就是 j 的时候,我们先移动 j ,可以避免将数据移动错误,后面会有体会。

当移动 j 时,就开始比较 j 是否比基准数大,如果大于或者等于就 j–,否则再看 i,如果 i 小于等于6,则i++ 再与基准数进行比较,否则 i 就要与 j指向的值互换,我们拿上面那个看第一步:看j的值比6小,然后看i,i的值是6,所以i++,后面 i继续++,4,3,5都比6小,所以 i 就移动到了7下面。

到这里,j 所指向的值要与 i 所指向的值互换。

互换完成,后面在比较 j 所指向的位置是否比基准数大,如果大就j–;这里 7 , 9 ,都比6大,所以j–,进行两次,j 就到达了4的下面。

4比6小,所以要再看 i,i 指向0,所以 i需要 i++,到 1,1也小于6, 所以 i 还需要++,到这里 i 就和j指向同一个数4,然后 i = j 了,不能够满足条件,所以就要进行互换,将 i 指向的数,与基准数互换,这一轮比较就结束了,到这里,基准数6的左边都比6小,右边都比6大。

后面还是按照这个来分别再基准数6的左右开始比较。

后面就找这样来,在左右两边再各自将第一个元素作为基准数进行排序。

以此类推,就好了,我把代码贴上。

数组排序c语言数组排序方法

数组排序c语言数组排序方法

数组排序c语言数组排序方法在C语言中,可以使用多种排序算法对数组进行排序。

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等。

下面将详细介绍这些排序算法的原理、实现以及时间复杂度。

1. 冒泡排序(Bubble Sort):冒泡排序是一种简单的排序算法,其基本思想是重复地在相邻的元素之间进行比较和交换,将最大的元素逐渐“浮”到数组的尾部。

具体实现过程如下:cvoid bubbleSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {for (int j = 0; j < n-1-i; j++) {if (arr[j] > arr[j+1]) {交换相邻元素int temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}冒泡排序的时间复杂度为O(n^2),其中n为数组长度。

2. 选择排序(Selection Sort):选择排序也是一种简单的排序算法,其基本思想是每次从未排序的部分中选取最小(或最大)的元素,放到已排序部分的末尾。

具体实现过程如下:cvoid selectionSort(int arr[], int n) {for (int i = 0; i < n-1; i++) {int minIndex = i;for (int j = i+1; j < n; j++) {if (arr[j] < arr[minIndex]) {minIndex = j;}}将最小元素交换到已排序部分的末尾int temp = arr[i];arr[i] = arr[minIndex];arr[minIndex] = temp;}选择排序的时间复杂度为O(n^2)。

3. 插入排序(Insertion Sort):插入排序的基本思想是将数组分为已排序和未排序两部分,每次从未排序部分选择一个元素,插入到已排序部分的正确位置。

C函数qsort的简介和用法,新手入门

C函数qsort的简介和用法,新手入门

自定义比较函数
比较函数的名字是自定义的(这里我们用CMP命名); Cmp:qsort 要求提供的这个函数是一个需要自己定义的比较函 : 要求提供的这个函数是一个需要自己定义的 自己定义 比较函数使得qsort通用性更好。有了比较函数 通用性更好。 数,比较函数使得 通用性更好 有了比较函数qsort可以实 可以实 现对数组,字符串,结构体等结构进行升序或降序排序。 现对数组,字符串,结构体等结构进行升序或降序排序。 Int Cmp(const void *a , const void *b )中有两个元素作为参数, 中有两个元素作为参数, 中有两个元素作为参数 返回一个int值 如果比较函数返回大于0, 返回一个 值, 如果比较函数返回大于 ,qsort就认为 a>b , 就认为 如果比较函数返回等于0 就认为a 这两个元素相等, 如果比较函数返回等于 qsort就认为 和b 这两个元素相等,返 就认为 回小于零 qsort就认为 a<b 。 就认为 qsort 知道元素大小,就可以把大的放到前面去。 知道元素大小,就可以把大的放到前面去。 如果你的比较函数放回本来应该是1 如果你的比较函数放回本来应该是 的(a>b),你比较函数却返 你比较函数却返 小于零的)那么qsort认为 认为a<b 的,就把 b放到前面 回一个 -1 (小于零的)那么 认为 放到前面 但实际上是a大于 大于b的 所以就造成升降序的差别了。 去,但实际上是 大于 的,所以就造成升降序的差别了。 简单来说,比较函数的作用就是给 简单来说,比较函数的作用就是给qsort指明元素的大小是怎么 指明元素的大小是怎么 比较的。 比较的。
应用qsort对结构体二级排序: 对结构体二级排序: 应用 对结构体二级排序
#include <stdio.h> #include <stdlib.h> struct coord { int x; int y; }data[100]; int cmp(struct coord *a ,struct coord *b) { if(a->x != b->x) return a->x - b->x; ////按照 从小到大排序,当x相等时按照 从大到小排序 按照x从小到大排序 相等时按照y从大到小排序 按照 从小到大排序, 相等时按照 else return a->y - b->y ; } void main() { int sum=0,n; int i,j; freopen("in.txt","r",stdin); while(scanf("%d",&n)!=EOF&&n) { for(i=0;i<n;i++) scanf("%d %d",&data[i].x,&data[i].y); for(i=0;i<n;i++) printf("%d %d ",data[i].x,data[i].y); printf("\n"); qsort(data,n,sizeof(data[0]),cmp); for(i=0;i<n;i++) printf("%d %d ",data[i].x,data[i].y); printf("\n"); } } 输入: 输入: 5 22 21 43 39 42 0

C语言快速排序算法

C语言快速排序算法

C语言快速排序算法(一)概述快速排序(Quick Sort)是一种有效的排序算法。

虽然算法在最坏的情况下运行时间为O(n^2),但由于平均运行时间为O(nlogn),并且在内存使用、程序实现复杂性上表现优秀,尤其是对快速排序算法进行随机化的可能,使得快速排序在一般情况下是最实用的排序方法之一。

快速排序被认为是当前最优秀的内部排序方法。

(二)实现快速排序的实现基于分治法,具体分为三个步骤。

假设待排序的序列为L[m..n]。

分解:序列L[m .. n]被划分成两个可能为空的子序列L[m .. pivot-1]和L[pivot+1 .. n],使L[m .. pivot-1]的每个元素均小于或等于L[pivot],同时L[pivot+1.. n]的每个元素均大于L[pivot]。

其中L[pivot]称为这一趟分割中的主元(也称为枢轴、支点)。

解决:通过递归调用快速排序,对子序列L[m .. pivot-1]和L[pivot+1 .. r]排序。

合并:由于两个子序列是就地排序的,所以对它们的合并不需要操作,整个序列L[m .. n]已排好序。

(三)性质内部排序快速排序是一种内部排序方法。

也就是说快速排序的排序对象是读入内存的数据。

比较排序快速排序确定元素位置的方法基于元素之间关键字大小的比较。

所有基于比较方法的排序方法的时间下界不会低于O(nlgn)。

这个结论的具体证明,请参考有关算法的书籍,例如《算法导论》(第一版)第8章(第二版在第七章QuickSort)。

在理想情况下,能严格地达到O(nlgn)的下界。

一般情况下,快速排序与随机化快速排序的平均情况性能都达到了O(nlgn)。

不稳定性快速排序是一种不稳定的排序方法。

简单地说,元素a1, a2的关键字有a1.key=a2.key,则不稳定的排序方法不能保证a1, a2在排序后维持原来的位置先后关系。

原地排序在排序的具体操作过程中,除去程序运行实现的空间消费(例如递归栈),快速排序算法只需消耗确定数量的空间(即S(1),常数级空间)。

【c语言中sort的用法详解】c语言sort

【c语言中sort的用法详解】c语言sort

【c语言中sort的用法详解】c语言sortc语言中sort的用法详解c语言中sort的用法详解c语言中sort的用法的用法sort是STL中提供的算法,头文件为#includealgorithm以及using namespace std;函数原型如下:1 2 3 4 5 template class RandomAccessIterator void sort ( RandomAccessIterator first, RandomAccessIterator last );template class RandomAccessIterator, class Compare void sort ( RandomAccessIterator first, RandomAccessIterator last, Compare comp );使用第一个版本是对[first,last)进行升序排序,默认操作符为““,第二个版本使用comp函数进行排序控制,comp包含两个在[first,last)中对应的值,如果使用""则为升序排序,如果使用""则为降序排序,分别对int、float、char以及结构体排序例子如下: 1 2 3 4 56 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 5556 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 #includestdio.h #includealgorithm #includestring using namespace std;struct product{ char name;float price;};int array_int={4,1,2,5,3};char array_char={"a","c","b","e","d"};double array_double={1.2,2.3,5.2,4.6,3.5};//结构比较函数(按照结构中的浮点数值进行排序)bool compare_struct_float(const product a,const product b){ returna.priceb.price;} //结构比较函数(按照结构中的字符串进行排序)bool compare_struct_str(const product a,const product b){ return string()string();} //打印函数void print_int(const int* a,int length){ printf("升序排序后的int数组:¥n");for(int i=0;ilength-1;i++) printf("%d ",a[i]);printf("%d¥n",a[length-1]);} void print_char(const char* a,int length){ printf("升序排序后的char数组:¥n");for(int i=0;ilength-1;i++) printf("%c ",a[i]);printf("%c¥n",a[length-1]);} void print_double(const double* a,int length){printf("升序排序后的dobule数组:¥n");for(int i=0;ilength-1;i++) printf("%.2f ",a[i]);printf("%.2f¥n",a[length-1]);} void print_struct_array(struct product *array, int length) { for(int i=0;ilength;i++) printf("[ name: %s ¥t price: $%.2f ]¥n", array[i].name, array[i].price);puts("--");} void main() { struct product structs[] = {{"mp3 player", 299.0f},{"plasma tv", 2200.0f}, {"notebook", 1300.0f}, {"smartphone", 499.99f}, {"dvd player", 150.0f}, {"matches", 0.2f }};//整数排序sort(array_int,array_int+5);print_int(array_int,5);//字符排序sort(array_char,array_char+5);print_char(array_char,5);//浮点排序sort(array_double,array_double+5);print_double(array_double,5);//结构中浮点排序int len = sizeof(structs)/sizeof(struct product);sort(structs,structs+len,compare_struct_float);printf("按结构中float升序排序后的struct数组:¥n");print_struct_array(structs, len);//结构中字符串排序sort(structs,structs+len,compare_struct_str);printf("按结构中字符串升序排序后的struct数组:¥n");print_struct_array(structs, len);} sort函数的用法做ACM题的时候,排序是一种经常要用到的操作。

快速排序算法及源代码

快速排序算法及源代码

快速排序算法及源代码(C语言)2009年11月01日星期日 11:40快速排序(Quicksort)是对冒泡排序的一种改进。

由C. A. R. Hoare在1962年提出。

它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

假设要排序的数组是A[1]……A[N],首先任意选取一个数据(通常选用第一个数据)作为关键数据,然后将所有比它的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一躺快速排序。

一躺快速排序的算法是:1)、设置两个变量I、J,排序开始的时候I:=1,J:=N;2)以第一个数组元素作为关键数据,赋值给X,即X:=A[1];3)、从J开始向前搜索,即由后开始向前搜索(J:=J-1),找到第一个小于X 的值,两者交换;4)、从I开始向后搜索,即由前开始向后搜索(I:=I+1),找到第一个大于X 的值,两者交换;5)、重复第3、4步,直到I=J;例如:待排序的数组A的值分别是:(初始关键数据X:=49)A[1] A[2] A[3] A[4] A[5] A[6] A[7]: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 4965( 按照算法的第五步将又一次执行算法的第三步从后开始找进行第四次交换后: 27 38 13 49 76 9765( 按照算法的第四步从前面开始找大于X的值,97>49,两者交换,此时J:=4 )此时再执行第三不的时候就发现I=J,从而结束一躺快速排序,那么经过一躺快速排序之后的结果是:27 38 13 49 76 97 65,即所以大于49的数全部在49的后面,所以小于49的数全部在49的前面。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

C语言 QUICKSORT排序升序变降序
悬赏分:0 |解决时间:2009-11-21 15:26 |提问者:jason51122
#include <stdio.h>
#define NUMEL 7
int main()
{
int nums[NUMEL] = {67,32,45,73,98,101,99};
int i;
void quicksort(int [], int, int);
quicksort(nums, 0, NUMEL-1);
printf("The sorted list, in ascending order, is:\n");
for (i = 0; i < NUMEL; i++)
printf("%d ",nums[i]);
printf("\n");
return 0;
}
void quicksort(int num[], int lower, int upper)
{
int pivot;
int partition(int [], int, int);
pivot = partition(num, lower, upper);
if (lower < pivot)
quicksort(num, lower, pivot - 1);
if (upper > pivot)
quicksort(num, pivot + 1, upper);
return;
}
int partition(int num[], int left, int right)
{
int pivot, temp;
pivot = num[left]; /* "capture" the pivot value, which frees up one slot */ while (left < right)
{
/* scan from right to left */
while(num[right] >= pivot && left < right) /* skip over larger or equal values */
right--;
if (right != left)
{
num[left] = num[right]; /* move the higher value into the available slot */
left++;
}
/* scan from left to right */
while (num[left] <= pivot && left < right) /* skip over smaller or equal values */
left++;
if (right != left)
{
num[right] = num[left]; /* move lower value into the available slot */
right-- ;
}
}
num[left] = pivot; /* move pivot into correct position */
return(left); /* return the pivot index */
}
哪位高手能把这个升序变为降序急在线等
问题补充:
请问哪部分的符号改啊
if (lower < pivot)
quicksort(num, lower, pivot - 1);
if (upper > pivot)
quicksort(num, pivot + 1, upper);
这部分怎么办
最佳答案
修改partition()函数中的两处即可:
int partition(int num[], int left, int right)
{
int pivot, temp;
pivot = num[left];
while (left < right)
{
while(num[right] <= pivot && left < right) /*注意这里*/ right--;
if (right != left)
{
num[left] = num[right];
left++;
}
while (num[left] >= pivot && left < right) /*注意这里*/
left++;
if (right != left)
{
num[right] = num[left];
right-- ;
}
}
num[left] = pivot;
return(left);
}。

相关文档
最新文档