五种排序算法整理 一（堆排序，快速排序、插入排序、选择排序、冒泡排序）

一、堆排序

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("原始序列:
");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("
");
    printf("中间序列:
");
    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("
");
    }
    printf("最终序列:
");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("
");
}
void insert_sort() //简单插入排序
{
    int i,j,k,temp;
    printf("原始序列:
");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("
");
    printf("中间序列:
");
    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("
");
    }
    printf("最终序列:
");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("
");
}
void select_sort()  //简单选择排序
{
    int i,j,k,temp,ans;
    printf("原始序列:
");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("
");
    printf("中间序列:
");

    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("
");
    }

    printf("最终序列:
");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("
");
}
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("
");
        }

        //将基准元素填入相应位置
        v[i] = temp;
        //此时的i即为基准元素的位置
        //对基准元素的左边子区间进行相似的快速排序
        quickSort(begin,i-1);
        //对基准元素的右边子区间进行相似的快速排序
        quickSort(i+1,end);
    }
    //如果区间只有一个数，则返回
    else
        return;
}
void solve_quickSort()
{
    int i,j;
    printf("原始序列:
");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("
");
    printf("中间序列:
");

    quickSort(0,n-1);

    printf("最终序列:
");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("
");
}
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("
");
        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("原始序列:
");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("
");
    printf("中间序列:
");

    headSort(v,n);

    printf("最终序列:
");
    for( i=0; i<n; ++i)
    {
        printf("%d ",v[i]);
    }
    printf("
");
}
int main()
{
    int i,x;
    printf("输入序列长度:");
    scanf("%d",&n);
    for( i=0; i<n; ++i)
    {
        scanf("%d",&v[i]);
    }
    system("cls");
    printf ( "                                                                 
");
    printf ( "                                                                 
");
    printf ( "                                                                 
");
    printf ("--------------------------------------                           
");
    printf ("--------------------------------------
");
    printf ("--------丨[0]冒泡排序            丨---
");
    printf ("--------丨[1]简单插入排序        丨---
");
    printf ("--------丨[2]简单选择排序        丨---
");
    printf ("--------丨[3]快速排序            丨---
");
    printf ("--------丨[4]堆排序              丨---
");
    printf ("--------丨[5]结束                丨---
");
    printf ("----------输入相应数字----------------
");
    printf ( "                                                                 
");
    printf ( "                                                                 
");
    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("程序运行结束
");
    }
    else printf("输入错误
");
}