選擇排序演算法代碼並輸出運算時間

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;

}

選排序流程圖：