常见的排序算法

#include <stdio.h>
#include <time.h>
void Swap(int &a, int &b)
{
    int t = a;
    a = b;
    b = t;
}


//选择排序:交换移动次数少,O(n2)
void SelectSort(int a[],int n)//或者int *a   
{
    printf("选择排序
");
    for (size_t i = 0; i < n - 1; i++)
    {
        int minInt = a[i];
        int index = i;
        for (size_t j = i + 1; j < n; j++) //j从i+1开始
        {
            if (a[j] < minInt)
            {
                minInt = a[j];
                index = j;
            }
        }
        Swap(a[i], a[index]); // //这里一开始错写成了Swap(a[i], minInt);这就不是数组里面的交换了.所以要用个index.
        for (int k = 0; k < n; k++)
        {
            printf("%d  ", a[k]);
        }
        printf("
");
    }
}

//插入排序:
void InsertSort(int a[], int n)    //按照宝典编的.(有交换的机制)
{
    printf("插入排序
");
    int i, j;
    for (i = 1; i < n; i++)
    {
        int temp = a[i];

        //(1)写法1
/*
//         for (j = i-1; j >= 0; j--)    //因为temp的前一个不一定是它应该去的位置,所以要和前面的多个进行比较(所以j >= 0; j--)
//         {
//             if (temp < a[j])
//             {
//                 a[j + 1] = a[j];
//             }
//             else
//             {
//                 break;    //当temp不小于紧贴的前一个a[j]时,就代表它不用调整位置,因为前面的顺序都是调整好的.
//             }            //这里的break是必须的,否则j会一直自减.
//         }
//         a[j + 1] = temp;    //因为for循环j--.即使没有执行循环体,但是j = i-1是一定执行过了.所以无论执行循环体,都能妥善处理.
*/


        //(2)写法2(较简便)
        for (j = i - 1; j >= 0 && temp < a[j]; j--)
        {
            a[j + 1] = a[j];    //大于temp的要往后挪,留出插入的空间.
        }
        a[j + 1] = temp;    ////因为for循环j--.即使没有执行循环体,但是j = i-1是一定执行过了.所以无论执行循环体,都能妥善处理.可以拿排好的顺序验证.
    }
}

//冒泡排序
void BubbleSort(int a[], int n)
{
    printf("冒泡排序
");
    int i, j;

/*
//     (1)下沉形式
    for (i = 0; i < n-1; i++)  //i控制需要沉下去几个,沉下去n-1个就能确定最后的顺序.
    {
        for (j = 0; j < n - 1 - i; j++)    //j代表矩阵内需要比较几次
        {
            if (a[j] > a[j+1])
            {
                Swap(a[j], a[j + 1]);
            }
        }
    }
*/

    //(2)冒泡形式
    for (i = 0; i < n - 1; i++)
    {
        for (j = n - 1; j > i ; j--)
        {
            if (a[j] < a[j - 1])
            {
                Swap(a[j], a[j - 1]);
            }
        }
    }
}

//希尔排序
void ShellSort(int a[], int n)
{
    printf("希尔排序
");
    int i, j, h; //h:增量
    int temp;
    for (h = n / 2; h > 0; h /= 2)
    {
        for (i = h; i < n; i += h)
        {
            temp = a[i];
            for (j = i - h; j >= 0; j -= h)    //j包括0.  j -= h:一次跳h,找有没有比temp大的,往后挪,给temp让位.
            {
                if (temp < a[j])
                {
                    a[j + h] = a[j];
                }
                else
                    break;    //也可以写成插入排序的(2)
            }
            a[j + h] = temp;
        }
    }
}


//堆排序(采用Weiss的代码)
#define  LeftChild(i) (2 * (i) + 1)
void PercDown(int a[], int i, int n)
{
    int child;
    int temp;
    for (temp = a[i]; LeftChild(i) < n; i = child)
    {
        child = LeftChild(i);
        if (child != n - 1 && a[child + 1] > a[child])
        {
            child++;
        }
        if (temp < a[child])
        {
            a[i] = a[child];
        }
        else
        {
            break;
        }
    }
    a[i] = temp;   //此处的i是child赋值过来的
}

void HeapSort(int a[], int n)
{
    printf("堆排序
");
    int i;
    for ( i = n / 2; i >= 0; i--)    //对父结点有(i < = n/2)  这里结点序号从0开始和数组下标一致.
    {
        PercDown(a, i, n);    // 创建大顶堆,自下而上,自右向左(思想可以参见<大话数据结构的第400页>)
    }
    for (i = n-1; i > 0; i--)//i > 0因为没有必要和自身交换
    {
        Swap(a[0], a[i]);
        PercDown(a, 0, i);    //以结点0创建大顶堆(包括所有有效的结点),因为只是把1和最后的记录交换,而其他结点都不变.其实上面的PercDown(a, i, n)是先下面创建,然后上面创建,大顶堆的元素数量越来越多.
    }
}


//归并排序


int main()
{
    int a[] = { 5,4,9,8,7,6,0,1,3,2 };
    int len = sizeof(a) / sizeof(a[0]);//    也可以写作:int len = sizeof(a) / sizeof(int);182     //SelectSort(a, len);
    //InsertSort(a, len);
    //BubbleSort(a, len);
    //ShellSort(a, len);
    HeapSort(a, len);
    clockEnd = clock();
    for (int i = 0; i < len; i++)
    {
        printf("%d
", a[i]);
    }
    return 0;
}