首頁 > 軟體

C語言資料結構經典10大排序演演算法刨析

2022-02-25 19:00:46

1、氣泡排序

// 氣泡排序
#include <stdlib.h>
#include <stdio.h>

// 採用兩層迴圈實現的方法。
// 引數arr是待排序陣列的首地址，len是陣列元素的個數。
void bubblesort1(int *arr,unsigned int len)
{
  if (len<2) return; // 陣列小於2個元素不需要排序。

  int ii;    // 排序的趟數的計數器。
  int jj;    // 每趟排序的元素位置計數器。
  int itmp;  // 比較兩個元素大小時交換位置用到的臨時變數。

  // 44,3,38,5,47,15,36,26,27,2,46,4,19,50,48  
  for (ii=len-1;ii>0;ii--)  // 一共進行len-1趟比較。
  {
    for (jj=0;jj<ii;jj++)  // 每趟只需要比較0......ii之間的元素，ii之後的元素是已經排序好的。
    {
      if (arr[jj]>arr[jj+1])  // 如果前面的元素大於後面的元素，則交換它位的位置。
      {
        itmp=arr[jj+1];
        arr[jj+1]=arr[jj];
        arr[jj]=itmp;
      }
    }
  }
}

// 採用遞迴實現的方法。
// 引數arr是待排序陣列的首地址，len是陣列元素的個數。
void bubblesort2(int *arr,unsigned int len)
{
  if (len<2) return; // 陣列小於2個元素不需要排序。

  int ii;    // 排序的元素位置計數器。
  int itmp;  // 比較兩個元素大小時交換位置用到的臨時變數。

  for (ii=0;ii<len-1;ii++)  // 每趟只需要比較0......len-1之間的元素，len-1之後的元素是已經排序好的。
  {
    if (arr[ii]>arr[ii+1])  // 如果前面的元素大於後面的元素，則交換它位的位置。
    {
      itmp=arr[ii+1];
      arr[ii+1]=arr[ii];
      arr[ii]=itmp;
    }
  }

  bubblesort2(arr,--len);
}

int main(int argc,char *argv[])
{
  int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
  int len=sizeof(arr)/sizeof(int);

  bubblesort1(arr,len);

  // 顯示排序結果。
  int ii;
  for (ii=0;ii<len;ii++) printf("%2d ",arr[ii]);

  printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}

2、選擇排序

// 選擇排序
#include <stdlib.h>
#include <stdio.h>

// 交換兩個變數的值。
void swap(int *x,int *y)
{
  int itmp=*x;
  *x=*y;
  *y=itmp;
}

// 採用兩層迴圈實現的方法。
// 引數arr是待排序陣列的首地址，len是陣列元素的個數。
void selectsort1(int *arr,unsigned int len)
{
  if (len<2) return; // 陣列小於2個元素不需要排序。

  int ii;      // 排序的趟數的計數器。
  int jj;      // 每趟排序的元素位置計數器。
  int iminpos; // 每趟迴圈選出的最小值的位置（陣列的下標）。

  // 44,3,38,5,47,15,36,26,27,2,46,4,19,50,48  
  for (ii=0;ii<len-1;ii++)  // 一共進行len-1趟比較。
  {
    iminpos=ii;

    for (jj=ii+1;jj<len;jj++)  // 每趟只需要比較ii+1......len-1之間的元素，ii之前的元素是已經排序好的。
    {
      // 找出值更小的元素，記下它的位置。
      if (arr[jj]<arr[iminpos])  iminpos=jj;
    }

    // 如果本趟迴圈的最小的元素不是起始位置的元素，則交換它們的位置。
    if (iminpos!=ii) swap(&arr[ii],&arr[iminpos]);
  }
}

// 採用遞迴實現的方法。
// 引數arr是待排序陣列的首地址，len是陣列元素的個數。
void selectsort2(int *arr,unsigned int len)
{
  if (len<2) return; // 陣列小於2個元素不需要排序。

  int ii;        // 排序的趟數的計數器。
  int iminpos=0; // 每趟迴圈選出的最小值的位置（陣列的下標）。

  for (ii=1;ii<len;ii++)  
  {
    // 找出值更小的元素，記下它的位置。
    if (arr[ii]<arr[iminpos])  iminpos=ii;
  }

  // 如果本趟迴圈的最小的元素不是起始位置的元素，則交換它們的位置。
  if (iminpos!=0) swap(&arr[0],&arr[iminpos]);

  selectsort2(arr+1,--len);
}

int main(int argc,char *argv[])
{
  int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
  //int arr[]={3,4,5,1};
  int len=sizeof(arr)/sizeof(int);

  // selectsort1(arr,len);  // 採用兩層迴圈排序的方法。
  selectsort2(arr,len);  // 採用遞迴排序的方法。

  // 顯示排序結果。
  int ii; for (ii=0;ii<len;ii++) printf("%2d ",arr[ii]);

  printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}

3、插入排序

// 插入排序
#include <stdlib.h>
#include <stdio.h>

// 引數arr是待排序陣列的首地址，len是陣列元素的個數。
void insertsort(int *arr,unsigned int len)
{
  if (len<2) return; // 陣列小於2個元素不需要排序。

  int itmp;  // 當前需要排序的元素的值。
  int ii;    // 需要排序元素的計數器。
  int jj;    // 插入排序時，需要後移元素的計數器。

  for (ii=1;ii<len;ii++)
  {
    itmp=arr[ii];    // 待排序元素

    // 從已排序的最右邊開始，把大於當前排序的元素後移。
    // for (jj=ii-1;(jj>=0&&arr[jj]>itmp);jj--)
    for (jj=ii-1;jj>=0;jj--)
    {
      if (arr[jj]<=itmp) break;

      arr[jj+1]=arr[jj]; // 逐個元素後移。
    }

    arr[jj+1]=itmp; // 插入當前排序元素。
  }
}


int main(int argc,char *argv[])
{
  int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
  int len=sizeof(arr)/sizeof(int);

  insertsort(arr,len);   // 呼叫插入排序函數對陣列排序。

  // 顯示排序結果。
  int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}

4、希爾排序

// 希爾排序
#include <stdlib.h>
#include <stdio.h>

// 對希爾排序中的單個組進行排序。
// arr-待排序的陣列，len-陣列總的長度，ipos-分組的起始位置，istep-分組的步長（增量）。
void groupsort(int *arr, int len, int ipos,int istep)
{
  int itmp;  // 當前需要排序的元素的值。
  int ii;    // 需要排序元素的計數器。
  int jj;    // 插入排序時，需要後移元素的計數器。

  for (ii=ipos+istep;ii<len;ii=ii+istep) 
  {
    itmp=arr[ii];    // 待排序元素
      
    // 從已排序的最右邊開始，把大於當前排序的元素後移。
    // for (jj=ii-istep;(jj>=0&&arr[jj]>itmp);jj=jj-istep)
    for (jj=ii-istep;jj>=0;jj=jj-istep)
    {
      if (arr[jj]<=itmp) break;  

      arr[jj+istep]=arr[jj];  // 逐個元素後移。
    }

    arr[jj+istep]=itmp; // 插入當前排序元素。
  }
}

// 希爾排序，arr是待排序陣列的首地址，len是陣列的大小。
void shellsort(int *arr,unsigned int len)
{
  int ii,istep;

  // istep為步長，每次減為原來的一半取整數，最後一次必定為1。
  for (istep=len/2;istep>0;istep=istep/2)
  {
    // 共istep個組，對每一組都執行插入排序。
    for (ii=0;ii<istep;ii++)
    {
      groupsort(arr,len,ii,istep);
    }
  }
}

int main(int argc,char *argv[])
{
  int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
  int len=sizeof(arr)/sizeof(int);

  shellsort(arr,len);   // 呼叫插入排序函數對陣列排序。

  // 顯示排序結果。
  int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}

5、快速排序

// 快速排序
#include <stdlib.h>
#include <stdio.h>

void quicksort(int *arr,unsigned int len)
{
  if (len<2) return;  // 陣列的元素小於2個就不用排序了。

  int itmp=arr[0];  // 選取最左邊的數作為中心軸。
  int ileft=0;      // 左下標。
  int iright=len-1; // 右下標。
  int imoving=2;    // 當前應該移動的下標，1-左下標；2-右下標。

  while (ileft<iright)
  {
    if (imoving==2) // 移動右下標的情況。
    {
      // 如果右下標位置元素的值大於等於中心軸，繼續移動右下標。
      if (arr[iright]>=itmp) { iright--; continue; }
      
      // 如果右下標位置元素的值小於中心軸，把它填到左下標的坑中。
      arr[ileft]=arr[iright];
      ileft++;    // 左下標向右移動。
      imoving=1;  // 下次迴圈將移動左下標。
      continue;
    }

    if (imoving==1) // 移動左下標的情況。
    {
      // 如果左下標位置元素的值小等於中心軸，繼續移動左下標。
      if (arr[ileft]<=itmp) { ileft++; continue; }

      // 如果左下標位置元素的值大於中心軸，把它填到右下標的坑中。
      arr[iright]=arr[ileft];
      iright--;   // 右下標向左移動。
      imoving=2;  // 下次迴圈將移動右下標。
      continue;
    }
  }

  // 如果迴圈結束，左右下標重合，把中心軸的值填進去。
  arr[ileft]=itmp;

  quicksort(arr,ileft);             // 對中心軸左邊的序列進行排序。
  quicksort(arr+ileft+1,len-ileft-1); // 對中心軸右邊的序列進行排序。
}

int main(int argc,char *argv[])
{
  int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
  int len=sizeof(arr)/sizeof(int);

  quicksort(arr,len);   // 呼叫插入排序函數對陣列排序。

  // 顯示排序結果。
  int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}

6、歸併排序

// 採用遞迴的方法實現歸併排序
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// 採用遞迴的方法實現歸併排序函數。
// arr-待排序陣列的首地址，arrtmp-用於排序的臨時陣列的首地址
// start-排序區間第一個元素的位置，end-排序區間最後一個元素的位置。
void _mergesort(int *arr,int *arrtmp,int start,int end) 
{
  // 如果start>=end，表示該區間的元素少於兩個，遞迴終止。
  if (start>=end) return; 

  int mid=start+(end-start)/2;  // 計算排序區間中間的位置。

  int istart1=start,iend1=mid;  // 區間左邊元素的第一和最後一個元素的位置。
  int istart2=mid+1,iend2=end;  // 區間右邊元素的第一和最後一個元素的位置。

  _mergesort(arr,arrtmp,istart1,iend1);   // 對區間左邊元素遞迴排序。
  _mergesort(arr,arrtmp,istart2,iend2);   // 對區間右邊元素遞迴排序。

  int ii=start; // 已排序陣列arrtmp的計數器。

  // 把區間左右兩邊數列合併到已排序陣列arrtmp中。
  while (istart1<=iend1 && istart2<=iend2)
    arrtmp[ii++]=arr[istart1]<arr[istart2] ? arr[istart1++] : arr[istart2++];

  // 把左邊數列其它的元素追加到已排序陣列。
  while (istart1<=iend1) arrtmp[ii++]=arr[istart1++];

  // 把右邊數列其它的元素追加到已排序陣列。
  while (istart2<=iend2) arrtmp[ii++]=arr[istart2++];

  // 把已排序陣列arrtmp中的元素複製到arr中。
  memcpy(arr+start,arrtmp+start,(end-start+1)*sizeof(int));
}

// 排序主函數，arr為待排序的陣列的地址，len為陣列的長度。
void mergesort(int *arr,unsigned int len) 
{
  if (len<2) return;  // 小於兩個元素不需要排序。

  int arrtmp[len];  // 分配一個與待排序陣列相同大小的陣列。

  _mergesort(arr,arrtmp,0,len-1);  // 呼叫遞迴函數進行排序。
}

int main(int argc,char *argv[])
{
  int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};
  int len=sizeof(arr)/sizeof(int);

  mergesort(arr,len);

  // 顯示排序結果。
  int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}
// 採用迴圈的方法實現歸併排序函數
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int min(int x,int y) { return x<y ? x : y; }  // 取x和y中的較小者的值。

// 採用迴圈實現歸併排序，arr-待排序陣列的首地址，len--待排序陣列的長度。
void mergesort(int *arr,unsigned int len) 
{
  if (len<2) return;  // 小於兩個元素不需要排序。

  int *aa=arr;     // aa指向待排序的陣列。
  int *bb=(int *)malloc(len*sizeof(int)); // bb指向已排序的陣列。

  int iseg;    // 區間分段的計數器，1,2,4,8,16,...
  int istart;  // 區間起始位置的計數器。

  // 排序的趟數的迴圈。
  for (iseg=1;iseg<len;iseg=iseg*2) 
  {
    // 每趟排序選取區間的迴圈。
    for (istart=0;istart<len;istart=istart+iseg*2) 
    {
      // 把每個區間分成兩部分，ilow是起始位置，imid是中間位置，imax是結束位置。
      int ilow=istart;
      int imid=min(istart+iseg,len);     // 考慮分段不均的情況，imid不能超出len。
      int imax=min(istart+iseg*2,len);   // 考慮分段不均的情況，imax也不能超出len。

      int ii=ilow; // 已排序陣列的計數器。
      int istart1=ilow,iend1=imid;  // 待排序左邊數列的起始和結束位置。
      int istart2=imid,iend2=imax;  // 待排序右邊數列的起始和結束位置。

      // 把待排序左右兩邊數列合併到已排序陣列。
      while ((istart1<iend1) && (istart2<iend2))
        bb[ii++]=aa[istart1]<aa[istart2] ? aa[istart1++] : aa[istart2++];

      // 把左邊數列其它的元素追加到已排序陣列。
      while (istart1<iend1) bb[ii++]=aa[istart1++];

      // 把右邊數列其它的元素追加到已排序陣列。
      while (istart2<iend2) bb[ii++]=aa[istart2++];
    }

    // 交換一下兩個陣列的指標，準備下一趟的排序。
    int *ptmp=aa; aa=bb; bb=ptmp;
  }

  // 如果aa指向的不是原始陣列的指標，把aa中的內容複製到arr中。
  if (aa != arr) 
  {
    memcpy(arr,aa,len*sizeof(int));

    bb = aa;
  }

  free(bb);
}

int main(int argc,char *argv[])
{
  int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48,10};
  int len=sizeof(arr)/sizeof(int);

  mergesort(arr,len);

  // 顯示排序結果。
  int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}

7、堆排序

// 堆排序
#include <stdio.h>
#include <stdlib.h>

// 交換兩個元素的值。
void swap(int *a,int *b) { int temp=*b; *b=*a; *a=temp; }

// 採用迴圈實現heapify（元素下沉）。
// arr-待排序陣列的地址，start-待heapify節點的下標，end-待排序陣列最後一個元素的下標。
void heapify(int *arr,int start,int end) 
{
  // 確定父節點和左子節點的陣列下標。
  int dad=start;
  int son=dad*2+1;

  // 如果子節點的下標沒有超出範圍，迴圈繼續。
  while (son<=end) 
  { 
    // 先比較兩個子節點大小，選擇最大的。
    if ((son+1<=end) && (arr[son]<arr[son+1])) son++;

    // 如果父節點大於子節點代表調整完畢，直接跳出函數。
    if (arr[dad]>arr[son]) return;

    // 否則交換父子內容再繼續子節點和孫節點比較。
    swap(&arr[dad],&arr[son]);
    dad=son;
    son=dad*2+1;
  }
}

// 採用遞迴實現heapify。
void heapify1(int *arr,int start,int end) 
{
  // 確定父節點和左子節點的陣列下標。
  int dad=start;
  int son=dad*2+1;

  // 如果子節點的下標沒有超出範圍，迴圈繼續。
  if (son>end ) return;

  // 先比較兩個子節點大小，選擇最大的。
  if ((son+1<=end) && (arr[son]<arr[son+1])) son++;

  // 如果父節點大於子節點代表調整完畢，直接跳出函數。
  if (arr[dad]>arr[son]) return;

  // 否則交換父子內容再繼續子節點和孫節點比較。
  swap(&arr[dad],&arr[son]);

  heapify(arr,son,end);
}

void heapsort(int *arr, int len) 
{
  int ii;

  // 初始化堆，從最後一個父節點開始調整。
  for (ii=(len-1)/2;ii>=0;ii--) heapify(arr,ii,len-1);

  // 把第一個元素和堆最後一個元素交換，然後重新調整，直到排序完畢。
  for (ii=len-1;ii>0;ii--) 
  {
    swap(&arr[0],&arr[ii]);
    heapify(arr,0,ii-1);
  }
}

int main() 
{
  int arr[]={44,3,38,5,47,15,36,26,27,2,46,4,19,50,48};

  int len=sizeof(arr)/sizeof(int);

  heapsort(arr,len);

  // 顯示排序結果。
  int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}

8、計數排序

// 計數排序（基礎版）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 獲取待排序陣列的最大元素的值。
int arrmax(int *arr,unsigned int len)
{
  int ii=0;
  int imax=0;

  for (ii=0;ii<len;ii++) if (imax<arr[ii]) imax=arr[ii];

  return imax;
}

// 計數排序主函數，arr-待排序陣列的地址，len-陣列的長度。
void countsort(int *arr,unsigned int len) 
{
  if (len<2) return;

  int imax=arrmax(arr,len);  // 獲取待排序陣列的最大元素的值。
  int arrtmp[imax+1];        // 臨時陣列的大小為imax+1。

  memset(arrtmp,0,sizeof(arrtmp));  // 初始化臨時陣列。

  int ii,jj,kk;
  
  // 臨時陣列計數。
  for (ii=0;ii<len;ii++) arrtmp[arr[ii]]++;

  // 把臨時陣列計數的內容填充到arr中。
  ii=0;
  for (jj=0;jj<imax+1;jj++)
  {
    for (kk=0;kk<arrtmp[jj];kk++) arr[ii++]=jj;
  }
}

int main() 
{
  int arr[]={2,3,8,7,1,2,2,2,7,3,9,8,2,1,4,2,4,6,9,2};

  int len=sizeof(arr)/sizeof(int);

  int xx; for (xx=0;xx<len;xx++) printf("%2d ",arr[xx]); printf("n");

  countsort(arr,len);

  // 顯示排序結果。
  int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}

9、桶排序

// 桶排序
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// 採用兩層迴圈實現氣泡排序的方法。
// 引數arr是待排序陣列的首地址，len是陣列元素的個數。
void bubblesort(int *arr,unsigned int len)
{
  if (len<2) return; // 陣列小於2個元素不需要排序。

  int ii;    // 排序的趟數的計數器。
  int jj;    // 每趟排序的元素位置計數器。
  int itmp;  // 比較兩個元素大小時交換位置用到的臨時變數。

  // 44,3,38,5,47,15,36,26,27,2,46,4,19,50,48  
  for (ii=len-1;ii>0;ii--)  // 一共進行len-1趟比較。
  {
    for (jj=0;jj<ii;jj++)  // 每趟只需要比較0......ii之間的元素，ii之後的元素是已經排序好的。
    {
      if (arr[jj]>arr[jj+1])  // 如果前面的元素大於後面的元素，則交換它位的位置。
      {
        itmp=arr[jj+1];
        arr[jj+1]=arr[jj];
        arr[jj]=itmp;
      }
    }
  }
}

// 桶排序主函數，引數arr是待排序陣列的首地址，len是陣列元素的個數。
void bucketsort(int *arr,unsigned int len)
{
  int buckets[5][5];   // 分配五個桶。
  int bucketssize[5];  // 每個桶中元素個數的計數器。

  // 初始化桶和桶計數器。
  memset(buckets,0,sizeof(buckets));
  memset(bucketssize,0,sizeof(bucketssize));

  // 把陣列arr的資料放入桶中。
  int ii=0;
  for (ii=0;ii<len;ii++)
  {
    buckets[arr[ii]/10][bucketssize[arr[ii]/10]++]=arr[ii];
  }

  // 對每個桶進行氣泡排序。
  for (ii=0;ii<5;ii++)
  {
    bubblesort(buckets[ii],bucketssize[ii]);
  }

  // 把每個桶中的資料填充到陣列arr中。
  int jj=0,kk=0;
  for (ii=0;ii<5;ii++)
  {
    for (jj=0;jj<bucketssize[ii];jj++)
      arr[kk++]=buckets[ii][jj];
  }
}

int main(int argc,char *argv[])
{
  int arr[]={21,3,30,44,15,36,6,10,9,19,25,48,5,23,47};
  int len=sizeof(arr)/sizeof(int);

  int xx; for (xx=0;xx<len;xx++) printf("%2d ",arr[xx]); printf("n");

  bucketsort(arr,len);

  // 顯示排序結果。
  int ii; for (ii=0;ii<len;ii++) printf("%2d ",arr[ii]); printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}

10、基數排序

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

// 獲取陣列arr中最大值，arr-待排序的陣列，len-陣列arr的長度。
int arrmax(int *arr,unsigned int len)
{
  int ii,imax;

  imax=arr[0];

  for (ii=1;ii<len;ii++)
    if (arr[ii]>imax) imax=arr[ii];

  return imax;
}

// 對陣列arr按指數位進行排序。
// arr-待排序的陣列，len-陣列arr的長度。
// exp-排序指數，exp=1：按個位排序；exp=10：按十位排序；......
void _radixsort(int *arr,unsigned int len,unsigned int exp)
{
  int ii;
  int result[len];       // 存放從桶中收集後資料的臨時陣列。
  int buckets[10]={0};   // 初始化10個桶。

  // 遍歷arr，將資料出現的次數儲存在buckets中。
  for (ii=0;ii<len;ii++)
    buckets[(arr[ii]/exp)%10]++;

  // 調整buckets各元素的值，調整後的值就是arr中元素在result中的位置。
  for (ii=1;ii<10;ii++)
    buckets[ii]=buckets[ii]+buckets[ii-1];

  // 將arr中的元素填充到result中。
  for (ii=len-1;ii>=0;ii--)
  {
    int iexp=(arr[ii]/exp)%10;
    result[buckets[iexp]-1]=arr[ii];
    buckets[iexp]--;
  }
  
  // 將排序好的陣列result複製到陣列arr中。
  memcpy(arr,result,len*sizeof(int));
}

// 基數排序主函數，arr-待排序的陣列，len-陣列arr的長度。
void radixsort(int *arr,unsigned int len)
{
  int imax=arrmax(arr,len);    // 獲取陣列arr中的最大值。

  int iexp;    // 排序指數，iexp=1：按個位排序；iexp=10：按十位排序；......

  // 從個位開始，對陣列arr按指數位進行排序。
  for (iexp=1;imax/iexp>0;iexp=iexp*10)
  {
    _radixsort(arr,len,iexp);
    int yy; printf("exp=%-5d  ",iexp); for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("n");
  }
}

int main(int argc,char *argv[])
{
  int arr[]={144,203,738,905,347,215,836,26,527,602,946,504,219,750,848};
  int len=sizeof(arr)/sizeof(int);

  radixsort(arr,len);  // 基數排序。

  // 顯示排序結果。
  int yy; for (yy=0;yy<len;yy++) printf("%2d ",arr[yy]); printf("n");

  // system("pause");  // widnows下的C啟用本行程式碼。

  return 0;
}

到此這篇關於C語言資料結構經典10大排序演演算法刨析的文章就介紹到這了,更多相關C語言 排序演演算法內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！


相關文章

  • 德漢姆中學就讀條件 德漢姆中學就讀條件

    <em>Mac</em>Book项目 2009年学校开始实施<em>Mac</em>Book项目,所有师生配备一本<em>Mac</em>Book,并同步更新了校园无线网络。学校每周进行电脑技术更新,每月发送技术支持资料,极大改变了教学及学习方式。因此2011

    2021-06-01 09:32:01

  • 黑科技的輕簡出行，告別「電量焦慮症」：Anker氮化鎵超能充系列 黑科技的輕簡出行，告別「電量焦慮症」：Anker氮化鎵超能充系列

    综合看Anker超能充系列的性价比很高，并且与不仅和iPhone12/苹果<em>Mac</em>Book很配，而且适合多设备充电需求的日常使用或差旅场景，不管是安卓还是Switch同样也能用得上它，希望这次分享能给准备购入充电器的小伙伴们有所

    2021-06-01 09:31:42

  • 吳亦凡廠牌首秀，L4WUDU居然忘詞了，Rapper和明星比還是有差距！ 吳亦凡廠牌首秀，L4WUDU居然忘詞了，Rapper和明星比還是有差距！

    除了L4WUDU与吴亦凡已经多次共事，成为了明面上的厂牌成员，吴亦凡还曾带领20XXCLUB全队参加2020年的一场音乐节，这也是20XXCLUB首次全员合照，王嗣尧Turbo、陈彦希Regi、<em>Mac</em> Ova Seas、林渝植等人全部出场。然而让

    2021-06-01 09:31:34

  • IPFS、Chia、Bzz和ICP挖礦該怎麼選？哪一個更有優勢？ IPFS、Chia、Bzz和ICP挖礦該怎麼選？哪一個更有優勢？

    目前应用IPFS的机构：1 谷歌<em>浏览器</em>支持IPFS分布式协议 2 万维网 (历史档案博物馆)数据库 3 火狐<em>浏览器</em>支持 IPFS分布式协议 4 EOS 等数字货币数据存储 5 美国国会图书馆，历史资料永久保存在 IPFS 6 加

    2021-06-01 09:31:24

  • 有哪些事是買了雪佛蘭後才知道的？美事偷著樂，開拓者車主隨聊 有哪些事是買了雪佛蘭後才知道的？美事偷著樂，開拓者車主隨聊

    开拓者的车机是兼容苹果和<em>安卓</em>，虽然我不怎么用，但确实兼顾了我家人的很多需求：副驾的门板还配有解锁开关，有的时候老婆开车，下车的时候偶尔会忘记解锁，我在副驾驶可以自己开门：第二排设计很好，不仅配置了一个很大的

    2021-06-01 09:30:48

  • iPhone12在618最新定價，跌價幅度超過1400元，還等iPhone13嗎？ iPhone12在618最新定價，跌價幅度超過1400元，還等iPhone13嗎？

    不仅是<em>安卓</em>手机，苹果手机的降价力度也是前所未有了，iPhone12也“跳水价”了，发布价是6799元，如今已经跌至5308元，降价幅度超过1400元，最新定价确认了。iPhone12是苹果首款5G手机，同时也是全球首款5nm芯片的智能机，它

    2021-06-01 09:30:45

IT145.com E-mail:sddin#qq.com