本文目錄一覽：
c語言堆排序代碼
#includestdio.h
void shift(int a[] , int i , int m)
{
int k , t;
t = a[i]; k = 2 * i + 1;
while (k m)
{
if ((k m – 1) (a[k] a[k+1])) k ++;
if (t a[k]) {a[i] = a[k]; i = k; k = 2 * i + 1;}
else break;
}
a[i] = t;
}
void heap(int a[] , int n) //a 為排序數組，n為數組大小（編號0-n-1）
{
int i , k;
for (i = n/2-1; i = 0; i –) shift(a , i , n);
for (i = n-1; i = 1; i –)
{
k = a[0]; a[0] = a[i]; a[i] = k;
shift(a , 0 , i);
}
}
void main()
{
int a[10],i;
for(i=0;i10;i++)
scanf(“%d”,a[i]);
heap(a,10);
for(i=0;i10;i++)
printf(“%d”,a[i]);
}
怎樣用C語言對一串整行數從大到小排序
方法太多了，當然各種時間排序的時間複雜度和空間複雜度不同、穩定性也不同。最簡單的我覺得就是冒泡排序了，也最形像。/*
================================================
功能：選擇排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
算法思想簡單描述： 在要排序的一組數中，選出最小的一個數與第一個位置的數交換；
然後在剩下的數當中再找最小的與第二個位置的數交換，如此循環
到倒數第二個數和最後一個數比較為止。 選擇排序是不穩定的。算法複雜度O(n2)–[n的平方]
=====================================================
*/
void select_sort(int *x, int n)
{
int i, j, min, t; for (i=0; in-1; i++) /*要選擇的次數：0~n-2共n-1次*/
{
min = i; /*假設當前下標為i的數最小，比較後再調整*/
for (j=i+1; jn; j++)/*循環找出最小的數的下標是哪個*/
{
if (*(x+j) *(x+min))
{
min = j; /*如果後面的數比前面的小，則記下它的下標*/
}
}
if (min != i) /*如果min在循環中改變了，就需要交換數據*/
{
t = *(x+i);
*(x+i) = *(x+min);
*(x+min) = t;
}
}
}
/*
================================================
功能：直接插入排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
算法思想簡單描述： 在要排序的一組數中，假設前面(n-1) [n=2] 個數已經是排
好順序的，現在要把第n個數插到前面的有序數中，使得這n個數
也是排好順序的。如此反覆循環，直到全部排好順序。
直接插入排序是穩定的。算法時間複雜度O(n2)–[n的平方]
=====================================================
*/
void insert_sort(int *x, int n)
{
int i, j, t; for (i=1; in; i++) /*要選擇的次數：1~n-1共n-1次*/
{
/*
暫存下標為i的數。注意：下標從1開始，原因就是開始時
第一個數即下標為0的數，前面沒有任何數，單單一個，認為
它是排好順序的。
*/
t=*(x+i);
for (j=i-1; j=0 t*(x+j); j–) /*注意：j=i-1，j–，這裡就是下標為i的數，在它前面有序列中找插入位置。*/
{
*(x+j+1) = *(x+j); /*如果滿足條件就往後挪。最壞的情況就是t比下標為0的數都小，它要放在最前面，j==-1，退出循環*/
} *(x+j+1) = t; /*找到下標為i的數的放置位置*/
}
}
/*
================================================
功能：冒泡排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
算法思想簡單描述： 在要排序的一組數中，對當前還未排好序的範圍內的全部數，自上
而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較
小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要
求相反時，就將它們互換。
下面是一種改進的冒泡算法，它記錄了每一遍掃描後最後下沉數的
位置k，這樣可以減少外層循環掃描的次數。 冒泡排序是穩定的。算法時間複雜度O(n2)–[n的平方]
=====================================================
*/void bubble_sort(int *x, int n)
{
int j, k, h, t;
for (h=n-1; h0; h=k) /*循環到沒有比較範圍*/
{
for (j=0, k=0; jh; j++) /*每次預置k=0，循環掃描後更新k*/
{
if (*(x+j) *(x+j+1)) /*大的放在後面，小的放到前面*/
{
t = *(x+j);
*(x+j) = *(x+j+1);
*(x+j+1) = t; /*完成交換*/
k = j; /*保存最後下沉的位置。這樣k後面的都是排序排好了的。*/
}
}
}
}
/*
================================================
功能：希爾排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
算法思想簡單描述：
在直接插入排序算法中，每次插入一個數，使有序序列只增加1個節點，
並且對插入下一個數沒有提供任何幫助。如果比較相隔較遠距離（稱為
增量）的數，使得數移動時能跨過多個元素，則進行一次比較就可能消除
多個元素交換。D.L.shell於1959年在以他名字命名的排序算法中實現
了這一思想。算法先將要排序的一組數按某個增量d分成若干組，每組中
記錄的下標相差d.對每組中全部元素進行排序，然後再用一個較小的增量
對它進行，在每組中再進行排序。當增量減到1時，整個要排序的數被分成
一組，排序完成。
下面的函數是一個希爾排序算法的一個實現，初次取序列的一半為增量，
以後每次減半，直到增量為1。 希爾排序是不穩定的。
=====================================================
*/
void shell_sort(int *x, int n)
{
int h, j, k, t; for (h=n/2; h0; h=h/2) /*控制增量*/
{
for (j=h; jn; j++) /*這個實際上就是上面的直接插入排序*/
{
t = *(x+j);
for (k=j-h; (k=0 t*(x+k)); k-=h)
{
*(x+k+h) = *(x+k);
}
*(x+k+h) = t;
}
}
}/*
================================================
功能：快速排序
輸入：數組名稱（也就是數組首地址）、數組中起止元素的下標
================================================
*/
/*
====================================================
算法思想簡單描述： 快速排序是對冒泡排序的一種本質改進。它的基本思想是通過一趟
掃描後，使得排序序列的長度能大幅度地減少。在冒泡排序中，一次
掃描只能確保最大數值的數移到正確位置，而待排序序列的長度可能只
減少1。快速排序通過一趟掃描，就能確保某個數（以它為基準點吧）
的左邊各數都比它小，右邊各數都比它大。然後又用同樣的方法處理
它左右兩邊的數，直到基準點的左右只有一個元素為止。它是由
C.A.R.Hoare於1962年提出的。
顯然快速排序可以用遞歸實現，當然也可以用棧化解遞歸實現。下面的
函數是用遞歸實現的，有興趣的朋友可以改成非遞歸的。 快速排序是不穩定的。最理想情況算法時間複雜度O(nlog2n)，最壞O(n2)
=====================================================
*/
void quick_sort(int *x, int low, int high)
{
int i, j, t; if (low high) /*要排序的元素起止下標，保證小的放在左邊，大的放在右邊。這裡以下標為low的元素為基準點*/
{
i = low;
j = high;
t = *(x+low); /*暫存基準點的數*/ while (ij) /*循環掃描*/
{
while (ij *(x+j)t) /*在右邊的只要比基準點大仍放在右邊*/
{
j–; /*前移一個位置*/
} if (ij)
{
*(x+i) = *(x+j); /*上面的循環退出：即出現比基準點小的數，替換基準點的數*/
i++; /*後移一個位置，並以此為基準點*/
} while (ij *(x+i)=t) /*在左邊的只要小於等於基準點仍放在左邊*/
{
i++; /*後移一個位置*/
} if (ij)
{
*(x+j) = *(x+i); /*上面的循環退出：即出現比基準點大的數，放到右邊*/
j–; /*前移一個位置*/
}
} *(x+i) = t; /*一遍掃描完後，放到適當位置*/
quick_sort(x,low,i-1); /*對基準點左邊的數再執行快速排序*/
quick_sort(x,i+1,high); /*對基準點右邊的數再執行快速排序*/
}
}
/*
================================================
功能：堆排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
================================================
*/
/*
====================================================
算法思想簡單描述： 堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。
堆的定義如下：具有n個元素的序列（h1,h2,…,hn),當且僅當
滿足（hi=h2i,hi=2i+1）或（hi=h2i,hi=2i+1）(i=1,2,…,n/2)
時稱之為堆。在這裡只討論滿足前者條件的堆。 由堆的定義可以看出，堆頂元素（即第一個元素）必為最大項。完全二叉樹可以
很直觀地表示堆的結構。堆頂為根，其它為左子樹、右子樹。
初始時把要排序的數的序列看作是一棵順序存儲的二叉樹，調整它們的存儲順序，
使之成為一個堆，這時堆的根節點的數最大。然後將根節點與堆的最後一個節點
交換。然後對前面(n-1)個數重新調整使之成為堆。依此類推，直到只有兩個節點
的堆，並對它們作交換，最後得到有n個節點的有序序列。 從算法描述來看，堆排序需要兩個過程，一是建立堆，二是堆頂與堆的最後一個元素
交換位置。所以堆排序有兩個函數組成。一是建堆的滲透函數，二是反覆調用滲透函數
實現排序的函數。 堆排序是不穩定的。算法時間複雜度O(nlog2n)。*/
/*
功能：滲透建堆
輸入：數組名稱（也就是數組首地址）、參與建堆元素的個數、從第幾個元素開始
*/
void sift(int *x, int n, int s)
{
int t, k, j; t = *(x+s); /*暫存開始元素*/
k = s; /*開始元素下標*/
j = 2*k + 1; /*右子樹元素下標*/ while (jn)
{
if (jn-1 *(x+j) *(x+j+1))/*判斷是否滿足堆的條件：滿足就繼續下一輪比較，否則調整。*/
{
j++;
} if (t*(x+j)) /*調整*/
{
*(x+k) = *(x+j);
k = j; /*調整後，開始元素也隨之調整*/
j = 2*k + 1;
}
else /*沒有需要調整了，已經是個堆了，退出循環。*/
{
break;
}
}
*(x+k) = t; /*開始元素放到它正確位置*/
}
/*
功能：堆排序
輸入：數組名稱（也就是數組首地址）、數組中元素個數
*/
void heap_sort(int *x, int n)
{
int i, k, t;
int *p; for (i=n/2-1; i=0; i–)
{
sift(x,n,i); /*初始建堆*/
}
for (k=n-1; k=1; k–)
{
t = *(x+0); /*堆頂放到最後*/
*(x+0) = *(x+k);
*(x+k) = t;
sift(x,k,0); /*剩下的數再建堆*/
}
}
void main()
{
#define MAX 4
int *p, i, a[MAX];
/*錄入測試數據*/
p = a;
printf(“Input %d number for sorting :\n”,MAX);
for (i=0; iMAX; i++)
{
scanf(“%d”,p++);
}
printf(“\n”); /*測試選擇排序*/
p = a;
select_sort(p,MAX);
/**/
/*測試直接插入排序*/ /*
p = a;
insert_sort(p,MAX);
*/
/*測試冒泡排序*/ /*
p = a;
insert_sort(p,MAX);
*/ /*測試快速排序*/ /*
p = a;
quick_sort(p,0,MAX-1);
*/ /*測試堆排序*/ /*
p = a;
heap_sort(p,MAX);
*/ for (p=a, i=0; iMAX; i++)
{
printf(“%d “,*p++);
}
printf(“\n”);
system(“pause”);
}
c語言排序和查找？
1）利用readData()函數從data1.txt中讀入不同規模的數據存入數組，
編寫基於數組的順序查找算法，測試數據量為1萬、5萬、10萬、20萬、
30萬、40萬和50萬時的數據查詢時間。
算法代碼如下：

1 int seqsearch(int a[],int n,int key)
2 {
3 int k=n-1;
4 while(k=0a[k]!=key)
5 k–;
6 return (k);
7 }

2）利用readData()函數從data2.txt中讀入不同規模的有序數據存入數組，
編寫基於數組的二分查找算法，測試數據量為1萬、5萬、10萬、20萬、30萬、
40萬和50萬時的數據查詢時間。
算法代碼如下：

1 int binSearch(int a[],int n,int key)
2 {
3 int low=0;
4 int high=n-1;
5 int mid;
6 while(low=high)
7 {
8 mid=(low+high)/2;
9 if(a[mid]==key) return mid;
10 if(a[mid]key)
11 high=mid-1;
12 else
13 low=mid+1;
14 }
15 return -1;
16 }

3）請設計冒泡排序算法函數void bubbleSort(int a[],int n)，對a[1]..a[n]進行升序排序。
並測試在不同數據規模下的排序效率。
算法代碼如下：

1 void bubbleSort(int a[],int n)
2 {
3 int i=1,j,flag=1;
4 while(i=n-1flag)
5 {
6 flag=0;
7 for(j=1;j=n-1-i;j++)
8 if(a[j+1]a[j])
9 {
10 a[0]=a[j];
11 a[j]=a[j+1];
12 a[j+1]=a[0];
13 flag=1;
14 }
15 i++;
16 }
17 }

計算機C語言的堆排序原理，最好是一個排序的例子，舉數據進行現場排序
#includestdio.h
#define N 6
int j,k;
//建堆函數
void build(int *a,int i,int n){
int tmp;
k=i;
j=2*k+1;
while(j=n){
if((jn)a[j]a[j+1])
j++;
if(a[k]=a[j])
break;
tmp=a[k];
a[k]=a[j];
a[j]=tmp;
k=j;
j=2*j+1;
}
}
//打印數組元素
void prnt(int *a,int n){
int i;
printf(“\n”);
for(i=0;in;i++)
{
printf(“%d “,a[i]);
}
printf(“\n”);
}
//打印堆函數
void prnthp(int *a,int b1,int b2){
int size;
int h=0,sum=0,item=1;
int i,j,cnt,start,tmp;
size=b2-b1+1;
while(sum=size){
sum+=item;
h++;
item*=2;
}
item=1;
cnt=0;
start=b1;
tmp=1;
printf(“\n========================================\n”);
printf(” 堆：\n”);
while(1){
for(i=0;ih;i++){
for(j=0;jh-i;j++)
printf(” “);
/* for(j=0;ji+1;j++)
printf(” “);*/
for(j=0;jtmp;j++){
if(cntsize-1)
goto end;
printf(“%4d”,a[cnt++]);
}
printf(“\n”);
tmp*=2;
}
}
end:
printf(“\n”);
}
//打印排序好地數組
void prntar(int *a,int b2,int len){
int i;
printf(” 已排序： \n”);
for(i=0;ib2;i++)
printf(” “);
for(i=b2;i=len;i++)
printf(“%d “,a[i]);
printf(“\n”);
}
int main(){
int a[50];
int i;
int tmp;
int sum;
int len;
printf(” 堆排序\n”);
printf(“\n=============================================\n”);
printf(“\n請輸入堆排序的數組元素個數，回車結束:\n”);
scanf(“%d”,len);
printf(“\n請輸入待排序的數組以回車結束：\n”);
for(i=0;ilen;i++)
scanf(“%d”,a[i]);
tmp=1;sum=0;
while (sum+tmp=len){
sum+=tmp;
tmp*=2;
}
printf(“\n==============================================================\n”);
printf(“\n 初始數組：\n”);
prnt(a,len);
for(i=sum-1;i=0;i–)
build(a,i,len-1);
prnthp(a,0,len-1);
for(i=0;ilen-1;i++){
tmp=a[0];
a[0]=a[len-1-i];
a[len-1-i]=tmp;
build(a,0,len-2-i);
prnthp(a,0,len-2-i);
prntar(a,len-1-i,len-1);
}
printf(“\n===================================\n”);
printf(“\n 排序結果：\n”);
prnt(a,len);
printf(“\n=======================================\n”);
return 0;
}
原創文章，作者：IZFTB，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/316859.html
微信掃一掃 
支付寶掃一掃 