c排序算法比较

① c语言的两种排序

1、选择排序法

要求输入10个整数，从大到小排序输出

输入：2 0 3 -4 8 9 5 1 7 6

输出：9 8 7 6 5 3 2 1 0 -4

代码：

#include<stdio.h>

int main(int argc,const char*argv[]){

int num[10],i,j,k,l,temp;

//用一个数组保存输入的数据

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

{

scanf("%d",&num<i>);

}

//用两个for嵌套循环来进行数据大小比较进行排序

for(j=0;j<9;j++)

{

for(k=j+1;k<=9;k++)

{

if(num[j]<num[k])//num[j]<num[k]

{

temp=num[j];

num[j]=num[k];

num[k]=temp;

}

}

}

//用一个for循环来输出数组中排序好的数据

for(l=0;l<=9;l++)

{

printf("%d",num[l]);

}

return 0;

}

2、冒泡排序法

要求输入10个整数，从大到小排序输出

输入：2 0 3-4 8 9 5 1 7 6

输出：9 8 7 6 5 3 2 1 0-4

代码：

#include<stdio.h>

int main(int argc,const char*argv[]){

//用一个数组来存数据

int num[10],i,j,k,l,temp;

//用for来把数据一个一个读取进来

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

{

scanf("%d",&num<i>);

}

//用两次层for循环来比较数据，进行冒泡

for(j=0;j<9;j++)

{

for(k=0;k<9-j;k++)

{

if(num[k]<num[k+1])//num[k]<num[k+1]

{

temp=num[k];

num[k]=num[k+1];

num[k+1]=temp;

}

}

}

//用一个for循环来输出数组中排序好的数据

for(l=0;l<=9;l++)

{

printf("%d",num[l]);

}

return 0;

}

(1)c排序算法比较扩展阅读：

return 0代表程序正常退出。return是C++预定义的语句，它提供了终止函数执行的一种方式。当return语句提供了一个值时，这个值就成为函数的返回值。

return语句用来结束循环，或返回一个函数的值。

1、return 0，说明程序正常退出，返回到主程序继续往下执行。

2、return 1，说明程序异常退出，返回主调函数来处理，继续往下执行。return 0或return 1对程序执行的顺序没有影响，只是大家习惯于使用return(0)退出子程序而已。

② C语言比较大小排序问题

#define N 10//宏定义，用N代替10
#include "stdio.h"//标准输入输出库，你在控制台输入数据和显示数据用的
main()//主函数
{
int a[N],i,j,temp;//声明需要排序的数组a和排序用的的一些“小工具”，i、j、temp
printf("请输入%d个整数：\n",N);
for(i=0;i<N;i++)//这个循环是和用户交互，手动输入10个数理组成数组
scanf("%d",&a[i]);
for(i=0;i<N-1-i;i++)//i从前往后数
for(j=0;j<N-1-i;j++)//在每一个i（比如0，比如1）下从前往后数j
if(a[j]>a[j+1])//如果j比他后边的大，交换
{temp=a[j];a[j]=a[j+1];a[j+1]=temp;}//两数前后互换
//上边这个循环就是从前往后数a的元素，比如到a[0]，那么最大的数移到最后一位；在比如a[1]，倒数第二大的数移到倒数第二位（因为最大的在后边，你移步过去了？）
//为什么要走这么多次。每次j的循环都好比一个波浪，一次只能保证一个最大数到了最后一位，其他的可能还是乱序，所以要一浪接一浪。
//这个算法的巧妙之处在于，i只走一半，也就是i从0到4，而j每次也不用到最后一位（j<N-1-i），因为最后那i+1位已经排好了
//比较次数，i=0时9次，i=1时8次，i=2时7次，i=3时6次，i=4时5次，一共35次
printf("排序之后的数据序列：\n");
for(i=0;i<N;i++)//把排序后的数列显示出来，%5d代表每一个数占5位，就是排列的整齐点。
printf("%5d",a[i]);
printf("\n");
}

#include"stdio.h"
#define N 10
main()
{
int a[N],i,j,r,temp;
printf("请输入%d个整数：\n",N);
for(i=0;i<N;i++)
scanf ("%d",&a[i]);
for(i=0;i<N-1;i++)//用i遍历数组a。
{r=i;//局部的r值，i从0到8每次不同，r也不同。
for(j=i+1;j<N;j++)//j是从i当前的值一直到最后（前一种排序时每次j的结尾位置不同，到9，到8.到7。）
if(a[j]<a[r])r=j;//用r标记最小的一个值，
if(r!=i)//如果这个最小的值不是a[i]，对换，让i所在值变成最小，意思是a[0]最小，a[1]第二小，以此类推
{temp=a[r];a[r]=a[i];a[i]=temp;}
}
printf("排序之后的数据序列：\n");
for(i=0;i<N;i++)
printf("%5d",a[i]);
printf("\n");

//i=0，j循环9次；i=1，j循环8次。。。。一共45次
}

我把函数改了，这样可以测试，你去跑一下就明白过程了

#include"stdio.h"
#define N 10
main()
{
int count = 0;
int a[N],i,j,r,temp;
printf("请输入%d个整数：\n",N);
for(i=0;i<N;i++)
scanf ("%d",&a[i]);
for(i=0;i<N-1;i++)
{r=i;
for(j=i+1;j<N;j++){
if(a[j]<a[r])r=j;

count++;
printf("i:%d\tj:%d\tcount:%d\n",i,j,count);
}
if(r!=i)
{temp=a[r];a[r]=a[i];a[i]=temp;}
}
printf("排序之后的数据序列：\n");
for(i=0;i<N;i++)
printf("%5d",a[i]);
printf("\n%d\n",count);
}

③ c语言 比较法排序区别

1、稳定排序和非稳定排序的不同

简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。反之，就是非稳定的。

比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4,a2,a3,a5就不是稳定的了。

2、内排序和外排序的不同

在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；

在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。

3、算法的时间复杂度和空间复杂度不同

所谓算法的时间复杂度，是指执行算法所需要的计算工作量。

一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。

④ c语言三种排序

常用的c语言排序算法主要有三种即冒泡法排序、选择法排序、插入法排序。

一、冒泡排序冒泡排序：

是从第一个数开始，依次往后比较，在满足判断条件下进行交换。代码实现（以降序排序为例）

#include<stdio.h>

int main()

{

int array[10] = { 6,9,7,8,5,3,4,0,1,2 };

int temp;

for (int i = 0; i < 10; i++)

{//循环次数

for (int j = 0; j <10 - i-1; j++)

{

if (array[j] < array[j+1])

{//前面一个数比后面的数大时发生交换 temp = array[j];

array[j] = array[j+1];

array[j + 1] = temp;

}

}

} //打印数组 for (int i = 0; i < 10; i++) printf("%2d", array[i]); return 0;}}

二、选择排序以升序排序为例：

就是在指定下标的数组元素往后（指定下标的元素往往是从第一个元素开始，然后依次往后），找出除指定下标元素外的值与指定元素进行对比，满足条件就进行交换。与冒泡排序的区别可以理解为冒泡排序是相邻的两个值对比，而选择排序是遍历数组，找出数组元素与指定的数组元素进行对比。（以升序为例）

#include<stdio.h>

int main()

{

int array[10] = { 6,9,7,8,5,3,4,0,1,2 };

int temp, index;

for (int i = 0; i < 9; i++) {

index = i;

for (int j = i; j < 10; j++)

{

if (array[j] < array[index])

index = j;

}

if(i != index)

{

temp = array[i];

array[i] = array[index];

array[index] = temp;

}

for(int i=0;i<10:i++)

printf("%2d"array[i]）

return 0；

}

三、快速排序

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

void QuickSort(int* arr, int size)

{

int temp, i, j;

for(i = 1; i <size; i++)

for(j=i; j>0; j--)

{

if(arr[j] <arr[j-1])

{

temp = arr[j];

arr[j]=arr[j-1];

arr[j-1]=temp;

}

}

}

⑤ C语言排序比较

#include<stdio.h>
#include<stdlib.h>
#include <math.h>
#define L 8 //排序元素个数
#define FALSE 0
#define TRUE 1

typedef struct
{
int key;
char otherinfo;
}RecType;

typedef RecType Seqlist[L+1];
int num; //定义排序趟数的全局变量
Seqlist R;
//直接插入排序
void Insertsort()
{
int i,j,k,m=0;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=2;i<=L;i++)
{
if(R[i].key<R[i-1].key)
{
R[0]=R[i];
j=i-1;
while(R[0].key<R[j].key)
{
R[j+1]=R[j];
j--;
}
R[j+1]=R[0];
}
m++;
printf("\t\t第%d趟排序结果为（按回车键继续）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//希尔排序
void Shellsort()
{
int i,j,gap,x,m=0,k;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
gap=L/2;
while(gap>0)
{
for(i=gap+1;i<=L;i++)
{
j=i-gap;
while(j>0)
{
if(R[j].key>R[j+gap].key)
{
x=R[j].key;
R[j].key=R[j+gap].key;
R[j+gap].key=x;
j=j-gap;
}
else
{
j=0;
}
}
}
gap=gap/2;
m++;
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//冒泡排序
void Bubblesort()
{
int i,j,k;
int exchange;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=1;i<L;i++)
{
exchange=FALSE;
for(j=L;j>=i+1;j--)
{
if(R[j].key<R[j-1].key)
{
R[0].key=R[j].key;
R[j].key=R[j-1].key;
R[j-1].key=R[0].key;
exchange=TRUE;
}
}
if(exchange)
{
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",i);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
}
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}

int Partition(int i,int j) //i和j为形式参数，分别代表low和high
{
RecType pirot=R[i];
while(i<j)
{
while(i<j&&R[j].key>=pirot.key)
{
j--;
}
if(i<j)
{
R[i++]=R[j];
}
while(i<j&&R[j].key<=pirot.key)
{
i++;
}
if(i<j)
{
R[j--]=R[i];
}
}
R[i]=pirot;
return i;
}
//递归形式为快速排序
void Quicksort(int low,int high)
{
int pirotpos,k;
if(low<high)
{
pirotpos=Partition(low,high);
num++;
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",num);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
Quicksort(low,pirotpos-1);
Quicksort(pirotpos+1,high);
}
}
//选择排序
void Selectsort()
{
int i,j,k,h;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=1;i<L;i++)
{
h=i;
for(j=i+1;j<=L;j++)
{
if(R[j].key<R[h].key)
{
h=j;
}
}
if(h!=j)
{
R[0]=R[i];
R[i]=R[h];
R[h]=R[0];
}
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",i);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}

void Merge(int low,int mm,int high)
{
int i=low,j=mm+1,p=0;
RecType *R1;
R1=new RecType[high-low+1];
if(!R1)
{
printf("内存容量不够！");
}
while(i<=mm&&j<=high)
{
R1[p++]=(R[i].key<=R[j].key)?R[i++]:R[j++];
}
while(i<=mm)
{
R1[p++]=R[i++];
}
while(j<=high)
{
R1[p++]=R[j++];
}
for(p=0,i=low;i<=high;p++,i++)
{
R[i]=R1[p];
}
}

void MergePass(int length)
{
int i;
for(i=1;i+2*length-1<=L;i=i+2*length)
{
Merge(i,i+length-1,i+2*length-1);
}
if(i+length-1<L)
{
Merge(i,i+length-1,L);
}
}
//归并排序
void Mergesort()
{
int length,k,m=0,i;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(length=1;length<L;length*=2)
{
MergePass(length);
m++;
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//堆建
void CreateHeap(int root,int index)
{
int j,temp,finish;
j=2*root;
temp=R[root].key;
finish=0;
while(j<=index&&finish==0)
{
if(j<index)
{
if(R[j].key<R[j+1].key)
{
j++;
}
}
if(temp>=R[j].key)
{
finish=1;
}
else
{
R[j/2].key=R[j].key;
j=j*2;
}
}
R[j/2].key=temp;
}//堆排序
void Heapsort()
{
int i,j,temp,k;
for(i=(L/2);i>=1;i--)
{
CreateHeap(i,L);
}
for(i=L-1,k=1;i>=1;i--,k++)
{
temp=R[i+1].key;
R[i+1].key=R[1].key;
R[1].key=temp;
CreateHeap(1,i);
printf("\t\t第%d趟排序结果为（按回车键开始排序）：\n\t\t",k);
for(j=1;j<=L;j++)
{
printf("%5d",R[j].key);
}
getchar();
printf("\n");
}
}
void Heap()
{
int i;
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
getchar();
printf("\n");
Heapsort();
printf("\n\t\t排序的最终结果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}

main()
{
Seqlist S;
int i,k;
char ch1,ch2,q;
printf("\n\t\t请输入%d个待排序数据（按回车键分隔）：\n\t\t",L);
for(i=1;i<=L;i++)
{
scanf("%d",&S[i].key);
getchar();
printf("\t\t");
}
printf("\n\t\t排序数据已经输入完毕！");
ch1='y';
while(ch1=='y'||ch1=='Y')
{
printf("\n");
printf("\n\t\t 排 序 子 系 统 \n");
printf("\n\t\t*******************************************\n");
printf("\n\t\t* 1--------更新排序数据 *\n");
printf("\n\t\t* 2--------直接插入排序 *\n");
printf("\n\t\t* 3--------希 尔 排 序 *\n");
printf("\n\t\t* 4--------冒 泡 排 序 *\n");
printf("\n\t\t* 5--------快 速 排 序 *\n");
printf("\n\t\t* 6--------选 择 排 序 *\n");
printf("\n\t\t* 7--------归 并 排 序 *\n");
printf("\n\t\t* 8--------堆 排 序 *\n");
printf("\n\t\t* 0--------返 回 *\n");
printf("\n\t\t*******************************************\n");
printf("\n\t\t 请选择菜单号（0--8）：");
scanf("%c",&ch2);
getchar();
for(i=1;i<=L;i++)
{
R[i].key=S[i].key;
}
switch(ch2)
{
case '1':
printf("\n\t\t请输入%d个待排序数据（按回车键分隔）：\n\t\t",L);
for(i=1;i<=L;i++)
{
scanf("%d",&S[i].key);
getchar();
printf("\t\t");
}
printf("\n\t\t排序数据已经输入完毕！");
break;
case '2':
Insertsort();
break;
case '3':
Shellsort();
break;
case '4':
Bubblesort();
break;
case '5':
printf("\n\t\t原始数据为（按回车键开始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
num=0;
Quicksort(1,L);
printf("\n\t\t排序的最终结果是：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
printf("\n");
break;
case '6':
Selectsort();
break;
case '7':
Mergesort();
break;
case '8':
Heap();
break;
case '0':
ch1='n';
break;
default:
system("cls");
printf("\n\t\t 对不起，您的输入有误，请重新输入！\n");
break;
}
if(ch2!='0')
{
if(ch2=='2'||ch2=='3'||ch2=='4'||ch2=='5'||ch2=='6'||ch2=='7'||ch2=='8')
{
printf("\n\n\t\t排序输出完毕！");
printf("\n\t\t按回车键返回。");
q=getchar();
if(q!='\xA')
{
getchar();
ch1='n';
}
}
}
}
}

没有错啊！我刚才试了一下，没有错！你把工程命名的后缀名为.cpp就可以了。

⑥ 求C语言将数组元素大小排序！！

C语言将数组元素大小排序方法：

以下使用的是冒泡排序法实线数组从小到大排序。

思想：每次相邻两个数比较，若升序，则将大的数放到后面，一次循环过后，就会将最大的数放在最后。

10、2、3、4、5、6、9、8、7、1是输入的待排序的数列，经过第一次排序，将最大的,10放在最后，第二次排序，将剩下的2、3、4、5、6、9、8、7、1进行冒泡，将当前最大的9放在倒数第二的位置，以此类推。

以下是具体代码：

#include <stdio.h>

int main(){

int nums[10] = {10, 2, 3, 4, 5, 6, 9, 8, 7, 1};

int i, j, temp, isSorted;

//优化算法：最多进行 n-1 轮比较

for(i=0; i<10-1; i++){

isSorted = 1; //假设剩下的元素已经排序好了

for(j=0; j<10-1-i; j++){

if(nums[j] > nums[j+1]){

temp = nums[j];

nums[j] = nums[j+1];

nums[j+1] = temp;

isSorted = 0; //一旦需要交换数组元素，就说明剩下的元素没有排序好

}

}

if(isSorted) break; //如果没有发生交换，说明剩下的元素已经排序好了

}

for(i=0; i<10; i++){

printf("%d ", nums[i]);

}

printf(" ");

return 0;

}

(6)c排序算法比较扩展阅读：

其他将数组从小到大排序的算法

以下使用的是选择排序法实现数组从小到大排序。

思想：从第一个数开始，每次和后面剩余的数进行比较，若升序，则如果后边的数比当前数字小，进行交换，和后面的所有的数比较、交换后，就会将当前的最小值放在当前的位置

输入的序列为10、2、3、4、5、6、9、8、7、1进行一次排序后将最小的数放在了第一位(a[0]与它后面的所有数进行比较，若a[0]比后面的数大，进行交换)，以此类推。

以下是具体代码：

#include <stdio.h>

int main(void){

int a[1001];

int n,i,j,t;

scanf("%d",&n);//n为要排序的数的个数

//输入需要排序的数

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

scanf("%d",a+i);

//接下来进行排序

for(i=0;i<n-1;++i)//因为每次需要和a[i]后面的数进行比较,所以到a[n-2](倒数第2个元素)就行

{

for(j=i+1;j<n;++j)//j从i后一个开始,a[i]与a[j]进行比较

{

if(a[i]>a[j])//a[i]为当前值,若是比后面的a[j]大,进行交换

{

t=a[i];

a[i]=a[j];

a[j]=t;

}

}//每排序一次,就会将a[i](包括a[i])之后的最小值放在a[i]的位置

for(j=0;j<n;++j)

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

printf(" ");

}

return 0;

}

⑦ c语言做各种排序算法比较程序怎么做

按照程序设计的自顶向下，逐步求精的机构化程序设计思想来完成这个任务。
①大概的顶层框架是：随机数产生模块，文件保存模块，排序以及统计排序过程信息的模块。
②分别设计出随机数产生算法，三种排序算法。
③按照逻辑的顺序进行组装，并给出必要的过程信息。
算法的设计实现以及程序运行结果：

⑧ C语言，快速排序算法

0和N-1表示的是数组下标。快排每一趟排序的目的是使值比设定的key值小的数都排到数组前部分，大的都排到后部分；然后对这两部分用新的关键值key分别重复上一步的操作；递归，直到数组有序。
其中关键值key=a[low]。
用题目给定的数组模拟第一趟排序如下：
下标0123456789
值91647824661232551
low=0high=9
part_element=a[low]=9
进入for循环
进入第一个while
part_element<51，于是high--,high=8;
part_element<25，high--,high=7;
part_element>3,不满足，结束while
a[low]=a[0]=a[high]=a[7]=3,low++,low=1;
进入第二个while
part_element<16,不满足，结束while
a[high]=a[7]=a[low]=a[1]=16,high--,high=6
for第一个循环结束，数组如下
316478246612162551
low=1,high=6
for第二个循环同上，结束时数组如下
344782476612162551
low=2,high=3
for第三个循环，第一个while中high--以后，low==high，直接break跳出for循环，此时
344782476612162551
low=2,high=2
结束for以后
a[high]=a[2]=part_element=9,得到
34982476612162551
split函数returnhigh=2

quicksort函数中middle=2;
下面两句递归，仍然是调用split函数，对数组
0-2,3-9两部分分别重复上述操作

最后直到数组数据有序