C語言實現六種排序演算法

• C語言實現六種排序演算法
  • • 氣泡排序
    • 插入排序
    • 歸併排序
    • 快速排序
    • 希爾排序
    • 選擇排序

下載完整原始碼
Java語言版點此穿越

氣泡排序

從左到右依次比較相鄰兩個元素，如果大的在左邊則交換這兩個元素。
如果在依次遍歷中執行過交換操作，則再次遍歷，直到不發生元素交換。

int * sortByMaopao(int
 
 * num,int length)
{
    bool flag=true;
    while(flag==true)
    {
        flag=false;
        for(int i=0;i<length-1;i++)
        {
            if(num[i]>num[i+1])
            {
                num[i]=num[i]+num[i+1]-(num[i+1]=num[i]);
                flag=true;
            }
        }
    }
    return
 
 num;
}

插入排序

從左到右遍歷每個元素，遍歷到的元素作為待定元素。
待定元素與其左邊的元素逐個相比，如果左邊大則交換，如果右邊大則遍歷下一個待定元素。

int * sortByCharu(int * num,int length)
{
    for(int i=1;i<length;i++)
    {
        for(int j=i;j>0;j--)
        {
            if(num[j-1]>num[j])
            {
                num[j]=num[j]+num[j-1]-(num[j-1
 
]=num[j]);
            }
        }
    }

    return num;
}

歸併排序

如果被排序陣列長度大於2，將要排序的陣列從中間分為左右兩組，分別遞迴執行歸併排序，然後將排序後的兩組有序陣列進行排序合併。
如果被排序陣列長度不大於2，則直接進行排序。

int * sortByGuibing(int * num,int length)
{
    sort_guibing(num,0,length-1);
    return num;
}

int * sort_guibing(int * num, int start,int end)
{
    int mid=(start+end)/2;
    if(end-start>1){
        sort_guibing(num,start,mid);
        sort_guibing(num,mid+1,end);
    }
    compare_guibing(num,start,mid,mid+1,end);
    return num;
}

int * compare_guibing(int *num,int start1,int end1,int start2,int end2)
{
    int * temp=(int *)malloc(sizeof(int)*(end2+1));
    for(int index=start1;index<=end2;index++)
    {
        temp[index]=num[index];
    }
    int i=start1,j=start2,point=start1;
    while(i<=end1&&j<=end2)
    {
        if(temp[i]<=temp[j]){
            num[point]=temp[i];
            point++;
            i++;
        }else
        {
            num[point]=temp[j];
            point++;
            j++;
        }
    }
    while(i<=end1)
    {
        num[point]=temp[i];
        point++;
        i++;
    }
    while(j<=end2)
    {
        num[point]=temp[j];
        point++;
        j++;
    }
    return num;
}

快速排序

假設最左邊元素作為核心元素。
從最右邊遍歷陣列與核心元素相比，遇到比其小的則交換位置並終止遍歷，或者直到遍歷到核心元素終止遍歷。
再從核心元素原位置向右進行遍歷，遇到比其大的則交換位置並終止遍歷，或者直到遍歷到核心元素終止遍歷。
重複上面兩句直到遍歷完整個陣列，此時核心元素的位置已經確定。
對核心元素左邊的陣列遞迴執行快速排序，對核心元素右邊的陣列遞迴執行快速排序。

int * sortByKuaisu(int * num,int length)
{
    sort_kuaisu(num,0,length-1);
    return num;
}

int * sort_kuaisu(int * num,int start,int end)
{
    int mid=compare_kuaisu(num,start,end);
    if(start<end){
        sort_kuaisu(num,start,mid-1);
        sort_kuaisu(num,mid+1,end);
    }
    return num;
}

int compare_kuaisu(int * num,int start,int end)
{
    int result=start;
    while(start<end)
    {
        while(end>start)
        {
            if(num[end]<num[start])
            {
                num[start]=num[start]+num[end]-(num[end]=num[start]);
                result=end;
                start++;
                break;
            }
            end--;
        }
        while(start<end)
        {
            if(num[start]>num[end])
            {
                num[start]=num[start]+num[end]-(num[end]=num[start]);
                result=start;
                end--;
                break;
            }
            start++;
        }
    }
    return result;
}

希爾排序

定義陣列長度為偏移量。
如果偏移量比大於等於1則將偏移量除以2。
從偏移量位置向右遍歷陣列，將遍歷到的元素與其左邊相差偏移量個單位的元素進行比較，如果左邊的小則交換後繼續與左邊相差偏移量個單位的元素比較。
遍歷完成後偏移量折半，重複上一句。

int * sortByXier(int * num,int length)
{
    int mid=length;
    while(mid>=1)
    {
        mid/=2;
        for(int i=mid;i<length;i++)
        {
            int point = i;
            while(point-mid>=0&&num[point]<num[point-mid])
            {
                num[point]=num[point]+num[point-mid]-(num[point-mid]=num[point]);
                point-=mid;
            }

        }
    }
    return num;
}

選擇排序

從左向右遍歷陣列，每個元素與其右邊的所有元素相比，最小的放在所遍歷的位置。

int * sortByXuanze(int *num,int length)
{
    for(int i=0;i<length;i++)
    {
        for(int j=i+1;j<length;j++)
        {
            if(num[j]<num[i])
            {
                num[i]=num[i]+num[j]-(num[j]=num[i]);
            }
        }
    }
    return num;
}

Java語言版點此穿越