排序算法面试题（上）

> 1、插入排序：

插入排序 基本思想： 每一步将一个待排序的元素，按其排序码的大小，插入到前面已经排好序的一组元素的合适位置上去，直到元素全部插完为止。
当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经
排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序 进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移 元素集合越接近有序，直接插入排序算法的时间效率越高
最优情况下：时间效率为O(n)
最差情况下：时间复杂度为O( n^2)
空间复杂度：O(1)，它是一种稳定的排序算法

void InsertSort(DataType *a, size_t n)//插入排序
{
    for (size_t i = 0; i<n - 1; i++)//最后一个元素下标是n-1;
    {
        DataType end=i;
        DataType tmp = a[end + 1];
        while (end >= 0 && a[end]>tmp)//如果前一个数比后一个数大，则交换
        {
            a[end + 1] = a[end];//将end处的数据往后移
            end--;//指针指向前一个元素
        }
        a[end + 1] = tmp;//放入数据
    }

}

2、希尔排序：

又称缩小增量排序，是对直接插入排序的优化
1）预排序；
2）直接插入排序 在数据量太大的情况下，可以提高效率；

void XiErSort(DataType*a, size_t n)//希尔排序/相当加了个间隔，将数据分组处理
{
    int flag=3;
    while (flag > 1)
    {
        flag = flag / 3 + 1;//缩放范围，flag=1排序完成
        for (size_t i = 0; i<n - flag; i++)
        {
            int end = i;
            int tmp = a[end + flag];
            while (end >= 0 && a[end] > tmp)//如果前一个数比后一个数大，则交换
            {
                a[end + flag] = a[end];
                end -= flag;
            }
            a[end + flag] = tmp;

        }
        /*printf("排序后的元素为：");
        for (size_t i = 0; i < n; i++)
        {
            printf("%d ", a[i]);
        }
        printf("\n");*///测试
    }
}

> 3、堆排序

通过建堆的方法来进行排序。
1）建小堆，然后通过向上调整或向下调整算法，选出最小的那个数，然后用最后一个数覆盖第一个数，在进行向下调整算法 依次选出次小的，最终完成排序
2）建大堆同理。
时间复杂度o（n*logn）；
空间复杂度o（1）；

创建堆： 升序—>大堆，降序—>小堆 执行如下步骤，直到数组为空
把堆顶array[0]元素和当前最堆的最后一个元素交换
堆元素个数减1 由于第1步后根节点不再满足最堆定义，向下调整根结点 把一棵完全二叉树调整为堆，以及每次将堆顶元素交换后
进行调整的时间复杂度均为O(logn )，所以堆排序的时 间复杂度为：O(n*logn ) 堆排序是一种不稳定的排序算法

void Adjustdown(DataType*a, size_t n, int parent)//向下调整算法
{
    assert(a);
    int  child = 2 * parent + 1;
    while (child<n)//当左孩子存在
    {
        if (a[child + 1] < a[child] && (child + 1) < n)//当右孩子的值大于左孩子且右孩子存在时//注意这的条件判断
        {
            ++child;//指向右孩子
        }
        if (a[child]<a[parent])
        {
            Swap(&a[child], &a[parent]);

            parent = child;
            child = 2 * parent + 1;
        }
        else
        {
            break;
        }
    }
}
void HeapSort(DataType*a, size_t n)//建堆
{
    assert(a);
    for (int i = (n - 2) >> 1; i>=0 ;i--)
    {
        Adjustdown(a, n, i);
    }

    while (n>0)
    {
        printf("%d ", a[0]);
        a[0] = a[n-1];
        n--;
        Adjustdown(a, n, 0);

    }

}

4、选择排序：

每一趟(第i趟，i=0,1，…，n-2)在后面n-i个待排序的数据元素集合中选出关键码最小的数据元素，作为有序元素序列的第i个元素。待到第n-2趟 做完，待排序元素集合中只剩下1个元素，排序结束
在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中 的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中， 重复上述步骤，直到集合剩余1个元素
直接选择排序的时间复杂度为O(n^2 )； 它是一种不稳定的排序算法

void SelectSort(DataType*a, size_t n)
{
    int i = 0;
    int min = 0;
    int j = 0;
    for (i = 0; i < n - 1; i++)
    {
        min = i;//每次将min制成无序组起始下标
        for (j = i; j < n; j++)
        {
            if (a[min]>a[j])//找出最小元素
                min = j;
        }
        if (min != i)
        {
            Swap(&a[min], &a[i]);
        }

    }

5、冒泡排序：

所谓冒泡排序法，就是对一组数字进行从大到小或者从小到大排序的一种算法。具体方法是，相邻数值两两交换。从第一个数值开始，如果相邻两个数的排列顺序与我们的期望不同，则将两个数的位置进行交换（对调）；如果其与我们的期望一致，则不用交换。重复这样的过程，一直到最后没有数值需要交换，则排序完成。一般地，如果有N个数需要排序，则需要进行（N-1）趟起泡

void BubberSort(DataType*a, size_t n)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < n-1; i++)
    {
        for ( j = 0; j< n-1-i; j++)
        {
            if (a[j+1]<a[j])
            {
                Swap(&a[j + 1], &a[j]);
            }

        }
    }

}

测试代码：

#include"sort.h"
void InsertTest()
{
    int a[10] = { 2, 4, 5, 9, 3, 6, 8, 7, 1, 0 };
    InsertSort(a, sizeof(a) / sizeof(a[0]));
    SortPrint(a, sizeof(a) / sizeof(a[0]));
}
void XiErTest()
{
    int a[10] = { 9,8,7,6,5,4,3,2,1,0};
    XiErSort(a, sizeof(a) / sizeof(a[0]));
    SortPrint(a, sizeof(a) / sizeof(a[0]));

}
void HeapSorttest()
{
    int a[10] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
    HeapSort(a, sizeof(a) / sizeof(a[0]));

}
void SelectSortTest()
{
    int a[10] = { 1, 8, 7, 6,0,5, 4, 3, 2, 9};
    SelectSort(a, sizeof(a) / sizeof(a[0]));
    SortPrint(a, sizeof(a) / sizeof(a[0]));
}
void BubberSortTest()
{
    int a[10] = { 1, 8, 7, 6, 0, 5, 4, 3, 2, 9 };
    BubberSort(a, sizeof(a) / sizeof(a[0]));
    SortPrint(a, sizeof(a) / sizeof(a[0]));
}
int main()
{
    /*InsertTest();*/
    //XiErTest();
    //HeapSorttest();
    SelectSortTest();

    /*BubberSortTest();*/
    system("pause");
    return 0;
}