选择排序算法代码并输出运算时间

A. C语言各种排序算法比较次数和运行时间的计算，改如何写，算法我已经写好了。

1. 比较次数，你加个变量比较一次统计一下不就可以了。

2. 统计运行时间

time_tbeg=clock();
InsertSort(...);
time_tend=clock();

printf("%lf
",(end-beg)/CLOCKS_PER_SEC);

应该是要加头文件<time.h>

B. 选择排序法的算法

简单选择排序算法分析：在简单选择排序过程中，所需移动记录的次数比较少。最好情况下，即待排序记录初始状态就已经是正序排列了，则不需要移动记录。最坏情况下，需要移动记录的次数最多为3（n-1）（此情况中待排序记录并非完全逆序，给完全逆序记录排序的移动次数应为(n/2)*3，其中n/2向下取整）。简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况无关。当i=1时，需进行n-1次比较；当i=2时，需进行n-2次比较；依次类推，共需要进行的比较次数是∑ =(n-1)+(n-2)+…+2+1=n(n-1)/2，即进行比较操作的时间复杂度为O(n2)。
选择排序法 是对 定位比较交换法（也就是冒泡排序法） 的一种改进。在讲选择排序法之前我们先来了解一下定位比较交换法。为了便于理解，设有10个数分别存在数组元素a[0]～a[9]中。定位比较交换法是由大到小依次定位a[0]～a[9]中恰当的值（和武林大会中的比武差不多），a[9]中放的自然是最小的数。如定位a[0],先假定a[0]中当前值是最大数，a[0]与后面的元素一一比较，如果a[4]更大，则将a[0]、a[4]交换，a[0]已更新再与后面的a[5]～a[9]比较，如果a[8]还要大，则将a[0]、a[8]交换，a[0]又是新数，再与a[9]比较。一轮比完以后，a[0]就是最大的数了，本次比武的武状元诞生了，接下来从a[1]开始，因为状元要休息了，再来一轮a[1]就是次大的数，也就是榜眼，然后从a[2]开始，比出探花，真成比武大会了，当比到a[8]以后，排序就完成了。
下面给大家一个例子：
int main(void)
{
int a[10];
int i,j,t;
for ( i = 0; i < 10; i ++ ) scanf("%d",&a[ i ]); /*输入10个数，比武报名，报名费用10000￥ ^_^*/
for ( i = 0; i < 9; i ++ )
for ( j = i + 1; j < 10; j ++)
if ( a[ i ] < a[ j ] ) { t = a[ i ]; a[ i ] = a[ j ]; a[ j ] = t; } /*打不过就要让出头把交椅，不过a[ i ]比较爱面子，不好意思见 a[ j ]，让t帮忙*/
for( i = 0; i < 10; i ++) printf("%4d",a[ i ]); /*显示排序后的结果*/
return 0;
}
好啦，啰嗦了半天总算把定位比较排序法讲完了，这个方法不错，容易理解，就是有点麻烦，一把椅子换来换去，哎～
所以就有了下面的选择排序法，开始的时候椅子谁也不给，放在一边让大家看着，找个人k记录比赛结果，然后发椅子。具体来讲呢就是，改进定位比较排序法，但是这个改进只是一部分，比较的次数没变，该怎么打还是怎么打，就是不用换椅子了。每次外循环先将定位元素的小标i值记录到K，认为a[k]是最大元素其实k=i还是a[ i ]最大，a[k]与后面的元素一一比较，该交换的也交换，就是把K的值改变一下就完了，最后在把a[k]与a[ i ]交换，这样a就是最大的元素了。然后进入下一轮的比较。选择排序法与定位比较排序法相比较，比的次数没变，交换的次数减少了。
下面也写个例子：
由大到小时：
int main(void)
{
int a[10];
int i,j,t,k;
for ( i = 0; i < 10; i ++ ) scanf("%d",&a[ i ]); /*输入10个数，比武报名，报名费用10000￥ ^_^*/
for ( i = 0;i < 9;i ++ ) /*10个数，所以只需比9次*/
{
k = i; /*裁判AND记者实时追踪报道比赛情况*/
for ( j = i + 1; j < 10; j ++)
if ( a[ k ] < a[ j ] ) k = j; /*使a[k]始终表示已比较的数中的最大数*/
if （k！=i）
{ t = a[ i ]; a[ i ] = a[ k ]; a[ k ] = t;} /* t 发放奖品* /
}
for( i = 0; i < 10; i ++) printf("%4d",a[ i ]); /*显示排序后的结果*/
return 0;
}
由小到大时：
int main(void)
{
int a[10];
int i,j,t,k;
for ( i = 0; i < 10; i ++ ) scanf("%d",&a[ i ]); /*输入10个数，比武报名，报名费用10000￥ ^_^*/
for ( i = 0; i < 9; i ++ )
{
k = i; /*裁判AND记者实时追踪报道比赛情况*/
for ( j = i + 1; j < 10; j ++)
if ( a[ k ] > a[ j ] ) k = j;
if （k！=i）
{ t = a[ i ]; a[ i ] = a[ k ]; a[ k ] = t; }/* t 发放奖品*/
}
for( i = 9; i >= 0; i --) printf("%4d",a[ i ]); /*显示排序后的结果*/
return 0;
}
java选择排序法代码public static void main(String[] args) {
Random random=new Random();
int[] pData=new int[10];
for(int i=0;i<pData.length;i++){ //随机生成10个排序数
Integer a =random.nextInt(100);
pData[i]= a;
System.out.print(pData[i]+" ");
}
System.out.println();
pData=Choose(pData);
for(int i=0;i<pData.length;i++){
System.out.print(pData[i]+" ");
}
System.out.println();
}
public static int[] Choose(int[] pData){
System.out.println();
for (int i = 0; i < pData.length; i++) {
for (int j = i; j < pData.length; j++) {
if(pData[j]<pData[i]){
int a=pData[j];
pData[j]=pData[i];
pData[i]=a;
}
}
}
return pData;
}

C. C语言编程:选择法排序

选择排序是一种简单直观的排序算法。

工作原理：

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

性能：

选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。

选择排序的时间复杂度是O(n^2)

思想：

n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：

①初始状态：无序区为R[1..n]，有序区为空。

②第1趟排序

在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

……

③第i趟排序

第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

C语言版代码：

#include<stdio.h>
#include<math.h>

#defineMAX_SIZE101
#defineSWAP(x,y,t)((t)=(x),(x)=(y),(y)=(t))

voidsort(int[],int);/*selectionsort*/

intmain()
{
inti,n;
intlist[MAX_SIZE];
printf(":");
scanf_s("%d",&n);
if(n<1||n>MAX_SIZE){
fprintf(stderr,"Impropervalueofn
");
exit(1);
}
for(i=0;i<n;i++){/*randomlygeneratenumbers*/
list[i]=rand()*1000;
printf("%d",list[i]);
}
sort(list,n);
printf("
Sortedarray:
");
for(i=0;i<n;i++)/*printoutsortednumbers*/
printf("%d",list[i]);
printf("
");
return0;
}
voidsort(intlist[],intn)
{
inti,j,min,temp;
for(i=0;i<n-1;i++){
min=i;
for(j=i+1;j<n;j++)
if(list[j]<list[min])
min=j;
SWAP(list[i],list[min],temp);
}
}

D. 比较冒泡排序、插入排序、二分插入排序、选择排序、快速排序的运行时间。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#defineN20000//随机生成20000个测试数据

#defineMAXSIZE100000//用于要排序数组个数最大值
typedefstruct
{
	intr[MAXSIZE+1];	//用于存储要排序数组，r[0]用作哨兵或临时变量
	intlength;			//用于记录顺序表的长度
}SqList;

//交换L中数组r的下标为i和j的值
voidswap(SqList*L,inti,intj)
{
	inttemp=L->r[i];
	L->r[i]=L->r[j];
	L->r[j]=temp;
}

//冒泡排序
voidBubbleSort(SqList*L)
{
	inti,j;
	for(i=1;i<L->length;i++)
	{
		for(j=L->length-1;j>=i;j--)//注意j是从后往前循环液枝
		{
			if(L->r[j]>L->r[j+1])//若前者大于后者
			{
				swap(L,j,j+1);//交换L->r[j]与L->r[j+1]的值
			}
		}
	}
}

//选择排序
voidSelectSort(SqList*L)
{
	inti,j,min;

	for(i=1;i<L->length;i++)
	{
		min=i;
		for(j=i+1;j<=L->length;j++)
{
			if(L->r[min]>L->r[j])//如果有小于当前最小值的关键字
{
min=j;//将此关键字的下标赋值给min
升埋和}
}
		if(i!=min)//若min不等于i，说明找到最小值，交换
{
swap(L,i,min);
}
	}
}

//直接插入排序
voidInsertSort(SqList*L)
{
	inti,j;
	for(i=2;i<=L->length;i++)
	{
		if(L->r[i]<L->r[i-1])
		{
			L->r[0]=L->r[i];//设置哨兵
			for(j=i-1;L->r[j]>L->r[0];j--)
{
L->r[j+1]=L->r[j];//记录后移
}
			L->r[j+1]=L->r[0];//插入到正确位置
		}
	}
}
//二分插入排序
voidInsertSortTwo(SqList*L)
{
intlow,high,mid;
inti,j;
intn=L->length;
for(i=2;i<=n;i++)
{
吵盯L->r[0]=L->r[i];
low=1;
high=i-1;
while(low<=high)
{
mid=(low+high)/2;
if(L->r[mid]>L->r[0])
{
high=mid-1;
}
else
{
low=mid+1;
}
}
for(j=i-1;j>=high+1;j--)
{
L->r[j+1]=L->r[j];
}
L->r[high+1]=L->r[0];
}
}

//交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置
//此时在它之前(后)的记录均不大(小)于它
intPartition(SqList*L,intlow,inthigh)
{
	intpivotkey;

	pivotkey=L->r[low];//用子表的第一个记录作枢轴记录
	while(low<high)//从表的两端交替地向中间扫描
	{
		while(low<high&&L->r[high]>=pivotkey)
{
high--;
}
		swap(L,low,high);//将比枢轴记录小的记录交换到低端
		while(low<high&&L->r[low]<=pivotkey)
{
low++;
}
		swap(L,low,high);//将比枢轴记录大的记录交换到高端
	}
	returnlow;//返回枢轴所在位置
}

//对顺序表L中的子序列L->r[low..high]作快速排序
voidQSort(SqList*L,intlow,inthigh)
{
	intpivot;
	if(low<high)
	{
			pivot=Partition(L,low,high);//将L->r[low..high]一分为二，算出枢轴值pivot
			QSort(L,low,pivot-1);		//对低子表递归排序
			QSort(L,pivot+1,high);		//对高子表递归排序
	}
}

//对顺序表L作快速排序
voidQuickSort(SqList*L)
{
	QSort(L,1,L->length);
}

intdata[N];
SqListL1,L2,L3,L4,L5;

intmain()
{
inti;

clock_tstart_time,end_time;
intwork_time;

srand((int)time(0));
for(i=0;i<N;i++)
{
data[i]=rand()%N;//随机数
}

for(i=0;i<N;i++)
{
L1.r[i+1]=data[i];
}
L1.length=N;
L2=L3=L4=L5=L1;

printf("随机生成%d个测试数据
",N);

start_time=clock();//获取程序开始运算时间
printf("冒泡排序");
BubbleSort(&L1);
end_time=clock();//获取程序结束运算时间
work_time=end_time-start_time;//计算程序运算时间
printf("运行时间%d毫秒
",work_time);

start_time=clock();//获取程序开始运算时间
printf("直接插入排序");
InsertSort(&L2);
end_time=clock();//获取程序结束运算时间
work_time=end_time-start_time;//计算程序运算时间
printf("运行时间%d毫秒
",work_time);

start_time=clock();//获取程序开始运算时间
printf("二分插入排序");
InsertSortTwo(&L3);
end_time=clock();//获取程序结束运算时间
work_time=end_time-start_time;//计算程序运算时间
printf("运行时间%d毫秒
",work_time);

start_time=clock();//获取程序开始运算时间
printf("选择排序");
SelectSort(&L4);
end_time=clock();//获取程序结束运算时间
work_time=end_time-start_time;//计算程序运算时间
printf("运行时间%d毫秒
",work_time);

start_time=clock();//获取程序开始运算时间
printf("快速排序");
QuickSort(&L5);
end_time=clock();//获取程序结束运算时间
work_time=end_time-start_time;//计算程序运算时间
printf("运行时间%d毫秒
",work_time);

return0;
}

E. 编写函数实现对整数数组进行选择排序（从大到小），主函数中调用该函数对数组数据排序后输出

选择排序的算法是由n个元素的数组需要进行n-1轮的选择，每一轮颤拦选择，采用打擂台的思想，从中选择最大的元素，然卖猛后把最大的元素交换到待排序范围内的首位，然后再进行下一轮，直到n-1轮茄配胡排序结束就可以了。
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void select_sort(int a[],int n)
{ int i,j,k,t;
for(i=0; i<n-1; i++)
{ k=i;
for(j=i+1; j<n; j++)
if(a[j]>a[k])k=j;
t=a[i];
a[i]=a[k];
a[k]=t;
}
}
int main()
{ int n,i,a[1000];
srand(time(0));
scanf("%d",&n);
for(i=0; i<n; i++)
{ a[i]=rand()%101;
printf("%4d",a[i]);
}
printf("\n");
select_sort(a,n);
for(i=0; i<n; i++)
printf("%4d",a[i]);
printf("\n");
return 0;
}

F. 我的java排序算法程序，想计算运行时间，结果为0，求各路高手解答。

因为你的数太少，现在的CPU运行速度很快的 你的代码没贴完整 我自己修改了下弄了个完整的 输入了10000个整数 运行时间大概是110毫秒。
public class Test5 {
public static void main(String[] args) {
long begin = System.currentTimeMillis();
int[] s_array = new int[10000];
int n = s_array.length;
for (int i = 0; i < n; i++) {
s_array[i] = i;
}
for (int i = 0; i < n - 1; i++) {
int k = i;
for (int j = i + 1; j < n; j++) {
if (s_array[j] < s_array[k])
k = j;
}
if (k != i) {
int temp;
temp = s_array[i];
s_array[i] = s_array[k];
s_array[k] = temp;
}
}
long end = System.currentTimeMillis();
System.out.println();
System.out.print("排序结果：");
for (int i = 0; i < n; i++) {
System.out.print(s_array[i] + " ");
}
System.out.println();
System.out.println("选择排序法用时为：" + (end - begin));
System.out.println("选择排序法比较次数为：" + (n * (n - 1)) / 2);
}
}

G. 排序算法时间

计算一个算法所消耗的时间是没有意义的，因为一个算法所用的时间不仅仅取决于算法本身，还与实现算法所使用的编程语言，输入的数据，执行算法的的硬件环境等等密切相关。
所以，一般地，我们用算法的时间复杂度（有时还要考虑空间复杂度）来衡量一个算法的好坏。计算时间复杂度是建立在执行算法中任何一个指令所消耗的时间相同的假设之上的，所以只是对算法性能的一个参考。
下面我给出常见的几种排序算法的时间复杂度：
排序法 时间复杂度
冒泡排序 O(n^2)
快速排序 O(n*log2n)
选择排序 O(n^2)
二叉树排序 O(n*log2n)
插入排序 O(n^2)
堆排序 O(n*log2n)

H. 求 c语言选择排序法和 冒泡排序法代码！

选择排序：

void select_sort(int a[],int n) //传入数组的要排序的元素个数

{int i,j,min,t;

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

{ min=i; //min:当前最小值下标

for(j=i+1;j<n;j++) //扫描余下的部分

if(a[min]>a[j]) //若有其它元素更小，就记录其下标

min=j;

if(min!=i) //保若最小值不在排序区首位，就换到首位

{t=a[min]; a[min]=a[i]; a[i]=t;}

}

}

冒泡排序：

void bubble_sort(int a[], int n) //传入数组的要排序的元素个数

{ int i, j, t;

for (j=0; j<n-1; j++) //n个元素比较n-1轮

for (i= 0; i<n-1-j;i++) //比较相信的两个数

if(a[i]>a[i+1]) //若大小顺序不符，就交换

{t=a[i]; a[i]=a[i+1]; a[i+1]=t;

}

I. 用选择法对10个整数由大到小排序。要求画出流程图

选择排序的过程如下：

1. 从待排序的n个元素中找到最大的元素，将其锋哗与第n个元素交换位置。

2. 在剩余的n-1个元素中，再找到最大的元素，将其与第n-1个元素交换位置。

3. 重复上述步骤，直到只剩下一个元素为止。

其中，每经过一轮，就能确定出一个元素的位置。通过n-1轮选择，就能将这n个元素按照从大到小的顺序排好序。选择排序的时间复杂度为O(n^2)。

下面是银改行使用C语言实现选择排序算法的示例代码：

#include <stdio.h>

void selection_sort(int arr[], int n)

{

int i, j, max_idx;

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

max_idx = i;

for (j = i + 1; j < n; j++) {

if (arr[j] > arr[max_idx]) {

max_idx = j;

}

}

// 将找到的最大元素与当前位置交换

int temp = arr[i];

arr[i] = arr[max_idx];

arr[max_idx] = temp;

}

}

int main()

{

int i, n;

int arr[10] = {23, 4, 56, 77, 12, 45, 89, 34, 67, 90};

n = sizeof(arr) / sizeof(arr[0]);

// 输出排序前的列表

printf("排序前： ");

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

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

}

printf(" ");

// 调用选择排序函数

selection_sort(arr, n);

// 输出排序后的列表

printf("歼猛排序后： ");

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

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

}

printf(" ");

return 0;

}

选排序流程图：