常用排序算法實現

1、常見排序算法大致有以下幾種:冒泡排序、選擇排序、插入排序、希爾排序、歸并排序、快速排序、堆排序
2、各種排序算法的實現邏輯可簡單描述如下:
冒泡排序:不想說了

選擇排序:從前往后找到最大的一個與最后一個交換

插入排序:從第二個數開始,認為前面是一個有序數列向前插入

希爾排序: 以n/2為步長分組,插入排序

歸并排序 : 二分法遞歸,合并兩個有序數組

快速排序 : 第一個為中間值,從右往左找最比中間值小的放左邊,從左往右找比中間值大的放右邊,左右交叉時第一個放交叉處,遞歸交叉處左邊,遞歸交叉處右邊

堆排序 : 遞歸左比較父子大小并交換, 遞歸右比較父子大小并交換,重建左堆,重建右側堆

桶排序 :數據分塊兒,常用于大數據。

3、上代碼:

//插入排序
void insertFun(int A[], int n)
{
    for (int i=1; i<n; i++) {
        int k=i;
        while (k>=1&&A[k]<A[k-1]) {
            swap(&A[k],&A[k-1]);
            k--;
        }
    }
}
//歸并排序
void merge(int *a,int n,int begin,int end)
{
    if (end-begin<=1) {
        return;
    }
    
    merge(a,n,begin,begin+(end-begin+1)/2);
    merge(a,n,begin+(end-begin+1)/2+1,end);
    hebing(a,n,begin+(end-begin+1)/2+1,end);
}
//冒泡排序
void funPaoCompare(int *a,int n,int begin,int end)
{
    for (int i=begin; i<end+1; i++) {
        for (int j=begin; j<end+1-1-i; j++) {
            count++;
            if (a[j]>a[j+1]) {
                swap(&a[j], &a[j+1]);
            }
        }
    }
}
//選擇排序
void selectFun(int A[], int n)
{
    for (int i=0; i<n; i++) {
        int minIndex=i;
        for (int j=i+1; j<n; j++) {
            if (A[minIndex]>A[j]) {
                minIndex = j;
            }
        }
        if (minIndex!=i) {
            swap(&A[minIndex], &A[i]);
        }
    }
}
//希爾排序
void shellFun(int A[], int n)
{
    int w = n;
    while(floor(w/2)>=1)
    {
        w=floor(w/2);
        shellFun_detail(A,n,w);
    }
}
void shellFun_detail(int A[], int n, int s)
{
    for (int i=0; i<n; i+=s) {
        int k=i;
        for (int j=i-s; j>=0; j-=s) {
            if (A[k]<A[j]) {
                swap(&A[k], &A[j]);
                k=j;
            }
            else
            {
                break;
            }
        }
    }
}
//快速排序
void quickPai(int *a,int n,int begin,int end)
{
    if (end-begin<=0) {
        return;
    }
    if (end-begin==1&&a[begin]>a[end]) {
        
        swap(&a[begin], &a[end]);
        return;
    }
    int length = end-begin+1;
    int compare = begin,now = end;
    for (int i=begin;i<begin+length;i++) {
        if (compare<now&&a[compare]>a[now]) {
            swap(&a[compare],&a[now]);
            int temp = compare;
            compare = now;
            now = temp+1;
        }
        
        else if (compare>now&&a[compare]<a[now]) {
            
            swap(&a[compare],&a[now]);
            int temp = compare;
            compare = now;
            now = temp-1;
        }
        
        else if(compare<now)
        {
            now--;
        }
        else if (compare>now)
        {
            now++;
        }
    }
    quickPai(a,n,begin,compare-1);
    quickPai(a,n,compare+1,end);
}
//堆排序
void heap(int A[], int n, int s)
{
    if (left(s)>n&&right(s)>n) {
        return ;
    }
    if (left(s)<=n) {
        heap(A, n, left(s));
    }
    if (right(s)<=n) {
        heap(A, n, right(s));
    }
    int min = s;
    if (A[left(s)-1]<A[min-1]) {
        min =left(s);
    }
    if (A[right(s)-1]<A[min-1]) {
        min =right(s);
    }
    if (min!=s) {
        swap(&A[min-1],&A[s-1]);
        heap(A, n, left(s));
        heap(A, n, right(s));
    }
}
int left(int a)
{
    return 2*a;
}
int right(int a)
{
    return 2*a+1;
}
void swap(int *a, int *b)
{
    *a=*a^*b;
    *b=*b^*a;
    *a=*a^*b;
}
//輸出
void fun_out(int A[], int n)
{
   for (int i=0; i<n; i++) {
       
       NSLog(@"%i",A[i]);
   }
}

4、其他相關算法

//合并兩個有序數列
void heBing(int a[],int m,int b[],int n,int c[])
{    int i=0,j=0,w=0;    
    while (i<m&&j<n) {        
          if (a[i]<b[j]) {            
              c[w]=a[i];i++;w++;       
           }       
         else       
         {            
              c[w]=b[j];j++;w++;        
         }   
     }    
    while (i<m)
     {        
            c[w]=a[i];i++;w++;    
     }    
     while (j<n) 
     {        
            c[w]=b[j];j++;w++;    
     }
}
最后編輯于
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明:文章內容(如有圖片或視頻亦包括在內)由作者上傳并發布,文章內容僅代表作者本人觀點,簡書系信息發布平臺,僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 當我們進行數據處理的時候,往往需要對數據進行查找操作,一個有序的數據集往往能夠在高效的查找算法下快速得到結果。所以...
    Single_YAM閱讀 1,113評論 0 3
  • 概述 排序有內部排序和外部排序,內部排序是數據記錄在內存中進行排序,而外部排序是因排序的數據很大,一次不能容納全部...
    蟻前閱讀 5,223評論 0 52
  • 概述:排序有內部排序和外部排序,內部排序是數據記錄在內存中進行排序,而外部排序是因排序的數據很大,一次不能容納全部...
    每天刷兩次牙閱讀 3,747評論 0 15
  • 曾經的你是不是有過盔甲,也有過軟肋? 那個時候好像隨時可以征戰沙場,奮勇抗敵, 把現實,把流言, 統統踩在腳下 ,...
    Stefanie_暖暖閱讀 614評論 0 0
  • 浩氣盟各幫接到青鋒幫的知會,紛紛來到了瞿塘峽,還沒站穩腳跟,就聽說了白帝城的劇變,不由得各自在心里盤算起來。 不空...
    水月不會心閱讀 218評論 0 1