五種排序算法整理 一（堆排序，快速排序、插入排序、選擇排序、冒泡排序）

一、堆排序

1、部分概念

 

滿二叉樹：深度為k，且含有(2^k)-1個結點的二叉樹

完全二叉樹：深度為k的，又n個結點的，當且僅當其每一個節點都與深度為k的滿二叉樹種編號從1至n的節點一一對應時，稱為完全二叉樹

 

堆的結構可以分為大根堆和小根堆，是一個完全二叉樹

每個結點的值都大於其左孩子和右孩子結點的值，稱之為大根堆；每個結點的值都小於其左孩子和右孩子結點的值，稱之為小根堆。

（這個它們右兒子值與左兒子誰的值大誰的值小沒有要求）

1.父結點索引：(i-1)/2（這里計算機中的除以2，省略掉小數）

2.左孩子索引：2*i+1

3.右孩子索引：2*i+2

 

 

 2、堆排序過程

升序----使用大頂堆

降序----使用小頂堆

思想（這里我們用大頂堆）：

假設要對一個有n個元素的數組進行排序。這樣的話我們先把這個數組里面的前n個數據拿出來構建一個大頂堆。這個時候我們肯定能保證堆頂那個元素是最大的。然后我們把那個最大的元素放在數組的倒數第一個位置。然后在對數組里面前n-1個元素再構建一次大頂堆，這個時候再把堆頂元素拿出來放到數組倒數第二個位置。依次進行n-1次就完了。。。

 

怎么把一個二叉樹弄成大頂堆？看下面

 

 

由上面這個圖我么可以知道它的數組中元素順序是這樣：【9，1，6，4，5】 

我們發現1號位置的權值並不大於它的兒子的權值，所以我們給它左右兒子中那個權值大的兒子交換

 

 這個時候我們知道最大權值是9，那就讓最大權值放在數組倒數第一個位置，讓倒數第一個位置的權值和它交換一下

 

 這個時候原數組就變成了：【1，5，6，4，9】，然后就接着對這個二叉樹改造，使它變成大頂堆（這個時候第4和位置就不再參與）

 

 發現這樣就是一個大頂堆了

 

 數組：【4，5，1，6，9】

 

 又變成了大頂堆

 

 數組：【1，4，5，6，9】

 

 又變成了大頂堆

 

 數組：【1，4，5，6，9】

 

循環了5-1=4次，所以該結束了

 

最后結果就是【1，4，5，6，9】

 

剩余四種排序算法見下一篇博客：

五種排序算法整理 二（堆排序，快速排序、插入排序、選擇排序、冒泡排序）

 

全部代碼（這個是五種算法的代碼）：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define maxn 1005
int v[maxn],n,size=0;
void Bubble_sort()  //冒泡排序
{
    int i,j,temp;
    printf("原始序列:\n");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("\n");
    printf("中間序列:\n");
    for(i=0; i<n; ++i)
    {
        for(j=i+1; j<n; ++j)
        {
            if(v[i]>v[j])  //因為是從小到大排序，所以這個條件滿足就是交換他們的值
            {
                temp=v[i];
                v[i]=v[j];
                v[j]=temp;
            }
        }

        for( j=0; j<n; ++j)
        {
            printf("%d ",v[j]);
        }
        printf("\n");
    }
    printf("最終序列:\n");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("\n");
}
void insert_sort() //簡單插入排序
{
    int i,j,k,temp;
    printf("原始序列:\n");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("\n");
    printf("中間序列:\n");
    for(i=1; i<n; ++i)
    {
        temp=v[i];
        for(j=i-1; j>=0; --j)
        {
            if(v[j]>temp)
            {
                v[j+1]=v[j];
            }
            else break;
        }
        v[j+1]=temp;

        for( j=0; j<n; ++j)
        {
            printf("%d ",v[j]);
        }
        printf("\n");
    }
    printf("最終序列:\n");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("\n");
}
void select_sort()  //簡單選擇排序
{
    int i,j,k,temp,ans;
    printf("原始序列:\n");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("\n");
    printf("中間序列:\n");

    for(i=0; i<n-1; ++i)
    {
        temp=i;
        for(j=i+1; j<n; ++j)
        {
            if(v[j]<v[temp]) temp=j;
        }
        if(temp!=i)  //如果相等的話那它就不用換位置
        {
            ans=v[temp];
            v[temp]=v[i];
            v[i]=ans;
        }
        for( j=0; j<n; ++j)
        {
            printf("%d ",v[j]);
        }
        printf("\n");
    }

    printf("最終序列:\n");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("\n");
}
void quickSort(int begin,int end)  //快速排序
{
    int k;
    //如果區間不只一個數
    if(begin < end)
    {
        int temp = v[begin]; //將區間的第一個數作為基准數
        int i = begin; //從左到右進行查找時的“指針”，指示當前左位置
        int j = end; //從右到左進行查找時的“指針”，指示當前右位置
        //不重復遍歷
        while(i < j)
        {
            //當右邊的數大於基准數時，略過，繼續向左查找
            //不滿足條件時跳出循環，此時的j對應的元素是小於基准元素的
            while(i<j && v[j] > temp)
                j--;
            //將右邊小於等於基准元素的數填入右邊相應位置
            v[i] = v[j];
            //當左邊的數小於等於基准數時，略過，繼續向右查找
            //(重復的基准元素集合到左區間)
            //不滿足條件時跳出循環，此時的i對應的元素是大於等於基准元素的
            while(i<j && v[i] <= temp)
                i++;
            //將左邊大於基准元素的數填入左邊相應位置
            v[j] = v[i];
            for( k=0; k<n; ++k)
            {
                printf("%d ",v[k]);
            }
            printf("\n");
        }

        //將基准元素填入相應位置
        v[i] = temp;
        //此時的i即為基准元素的位置
        //對基准元素的左邊子區間進行相似的快速排序
        quickSort(begin,i-1);
        //對基准元素的右邊子區間進行相似的快速排序
        quickSort(i+1,end);
    }
    //如果區間只有一個數，則返回
    else
        return;
}
void solve_quickSort()
{
    int i,j;
    printf("原始序列:\n");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("\n");
    printf("中間序列:\n");

    quickSort(0,n-1);

    printf("最終序列:\n");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("\n");
}
void swap(int *x,int *y)
{
    int temp=*x;
    *x=*y;
    *y=temp;
}
int headSort(int* arr,int length)  //堆排序
{
    int idx,k;
    if(length<=0)
        return -1;
    //數組中順序存放的數據就對應完全二叉樹堆中的對應結點的值，現在調整為大根堆
    for( idx=length/2-1; idx>=0; --idx) //從最后一個非葉子結點開始調整為最大堆
    {
        adjust(arr,idx,length-1);  //最后一個非葉子結點和它的孩子比較調整
    }
    //排序，根結點后最后一個結點交換，調整
    for( idx=length-1; idx>0; --idx)
    {
        swap(&arr[0],&arr[idx]);  //每次選出一個最大的數放到末尾，也就是數組末尾
        for( k=0; k<n; ++k)
        {
            printf("%d ",v[k]);
        }
        printf("\n");
        adjust(arr,0,idx-1);  //調整根結點到idx-1個結點為大根堆
    }
    return 0;
}
void adjust(int* arr,int idx1,int idx2)
{
    int tmp,idx;
    if(idx1>=idx2||idx1<0||idx2<0)
        return ;
    tmp = arr[idx1];  //暫時存放要調整的數據
    for( idx=idx1*2+1; idx<=idx2; idx=idx*2+1) //從要調整的數據的左孩子開始比較
    {
        //選出左右孩子中的最大結點
        if(idx+1<=idx2 && arr[idx]<arr[idx+1])
            ++idx;
        if(arr[idx]>tmp)  //不滿足大根堆，調整
        {
            arr[idx1] = arr[idx];  //交換，可能破壞子樹滿足大根堆的性質
            idx1 = idx;  //本來這里要交換的，但時tmp暫時存放了初始arr[idx1]的值，這里每次比較都是和tmp比較,好比交換了，所以可以不用先交換
            //繼續向下調整，直到樹滿足大根堆性質
        }
        else
            break;
    }
    arr[idx1] = tmp;
}
void solve_heapSort()
{
    int i,j;
    printf("原始序列:\n");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("\n");
    printf("中間序列:\n");

    headSort(v,n);

    printf("最終序列:\n");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("\n");
}
int main()
{
    int i,x;
    printf("輸入序列長度:");
    scanf("%d",&n);
    for( i=0; i<n; ++i)
    {
        scanf("%d",&v[i]);
    }
    system("cls");
    printf ( "                                                                 \n");
    printf ( "                                                                 \n");
    printf ( "                                                                 \n");
    printf ("--------------------------------------                           \n");
    printf ("--------------------------------------\n");
    printf ("--------丨[0]冒泡排序            丨---\n");
    printf ("--------丨[1]簡單插入排序        丨---\n");
    printf ("--------丨[2]簡單選擇排序        丨---\n");
    printf ("--------丨[3]快速排序            丨---\n");
    printf ("--------丨[4]堆排序              丨---\n");
    printf ("--------丨[5]結束                丨---\n");
    printf ("----------輸入相應數字----------------\n");
    printf ( "                                                                 \n");
    printf ( "                                                                 \n");
    scanf("%d",&x);
    if(x==0)
    {
        system("cls");
        Bubble_sort();
    }
    else if(x==1)
    {
        system("cls");
        insert_sort();
    }
    else if(x==2)
    {
        system("cls");
        select_sort();
    }
    else if(x==3)
    {
        system("cls");
        solve_quickSort();
    }
    else if(x==4)
    {
        system("cls");
        solve_heapSort();
    }
    else if(x==5)
    {
        system("cls");
        printf("程序運行結束\n");
    }
    else printf("輸入錯誤\n");
}