码海拾遗：常用的其中排序算法

排序算法大致可分为两类：

　　比较排序，时间复杂度一般在O(nlogn) ~ O(n^2)之间，主要有冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序等

　　非比较排序，时间复杂度可达到O(n)，主要有计数排序、基数排序等

本文主要介绍常用的其中比较排序。

　　 1、冒泡排序

　　说明：冒泡排序是一种非常简单的排序算法，需要重复遍历需要排序的所有元素，依次比较相邻的两个元素，如果顺序错误就将两者位置调换，知道没有元素需要交换位置，排序结束。

　　平均时间复杂度：O(n^2)。

　　稳定性：稳定。

　　2、选择排序

　　说明：开始时找到序列中的最小（大）元素，放到序列的起始位置作为已排序序列，然后再从剩余未排序序列中找的最小（大）的元素，放到已排序序列的末尾；以此类推，直至所有元素都排序完成。

　　平均时间复杂度：O(n^2)。

　　稳定性：不稳定。

　　3、插入排序

　　说明：将未排序的元素在已排序的序列中从后向前找到相应的位置插入。

　　平均时间复杂度：O(n^2)。

　　稳定性：稳定

　　4、希尔排序

　　说明：又称递减增量排序，是插入排序的一种高速改进版本。

　　平均时间复杂度：希尔排序的时间复杂度与增量的选取有关，当增量为1时，为O(n^2)，Hibbard增量的希尔排序的时间复杂度为O(N^3/2)。

　　稳定性：不稳定

　　5、快速排序

　　说明：使用分而治之的策略把一个序列分成两个子序列

　　平均时间复杂度：O(nlogn)

　　稳定性：不稳定

　　6、归并排序

　　说明：建立在归并操作上的一种排序算法，由冯·诺依曼首次提出。

　　平均时间复杂度：O(nlogn)

　　稳定性：稳定

　　7、堆排序

　　说明：利用堆这种数据结构设计的排序算法，堆是一种近似完全二叉树的结构，并满足性质：以大顶堆为例，父节点的元素总大于子节点的元素。

　　平均时间复杂度：O(nlogn)

　　稳定性：不稳定

　　实现：my_sort.h

#pragma once

//两值交换
void swap(int& a, int& b);
void swap(int arr[],int i,int j);

//选择排序
void selectSort(int arr[], int arrSize);

//插入排序
void insertSort(int arr[], int arrSize);

//冒泡排序
void bubbleSort(int arr[], int arrSize);

//希尔排序
void shellSort(int arr[], int arrSize);

//快速排序
void quickSort(int arr[],int start,int end);

//归并排序
void mergeSort(int a[], int first, int last, int temp[]);
//将两个有序数列a[first...mid]和a[mid+1...last]合并。
void mergeArray(int a[], int first, int mid, int last, int temp[]);

//堆排序
void heapSort(int arr[], int arrSize);
//建堆
int buildHeap(int arr[], int arrSize);
//从指定节点开始向下进行堆调整
void heap(int arr[], int i, int size);

my_sort.cpp

#include "my_sort.h"

void swap(int & a, int & b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

void swap(int arr[], int i, int j)
{
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

//选择排序
void selectSort(int arr[], int arrSize)
{
    int min = 0;//初始时最小值位置
    for (int i = 0; i < arrSize - 1; ++i)
    {
        min = i;
        for (int j = i + 1; j < arrSize; ++j)
            if (arr[min] > arr[j])
                min = j;

        if (min != i)
            swap(arr[min], arr[i]);
    }
}

//插入排序
void insertSort(int arr[], int arrSize)
{
    int i, j;
    for (i = 1; i < arrSize; ++i)
    {
        int tmp = arr[i];
        for (j = i; j > 0 && tmp<arr[j-1]; --j)
        {
            arr[j] = arr[j - 1];
        }
        arr[j] = tmp;
    }
}

//冒泡排序
void bubbleSort(int arr[], int arrSize)
{
    for (int i = 0; i < arrSize; ++i)
    {
        for (int j = 1; j < arrSize - i; ++j)
        {
            if (arr[j] < arr[j - 1])
                swap(arr[j], arr[j - 1]);
        }
    }
}

//希尔排序
void shellSort(int arr[], int arrSize)
{
    int step = arrSize / 2;//设置步长
    int i, j;
    int tmp;
    while (step >= 1)
    {
        for (i = step; i < arrSize; ++i)
        {
            tmp = arr[i];
            j = i - step;
            while (j > 0 && arr[j] > tmp)
            {
                arr[j + step] = arr[j];
                j -= step;
            }
            arr[j + step] = tmp;
        }
        step /= 2;
    }
}

//快速排序
void quickSort(int arr[], int start, int end)
{
    if (start >= end)
        return;

    int i = start;//起始位置
    int j = end;//最后一个元素的位置

    //基准值
    int tmp = arr[start];//以起始位置为基准

    while (i < j)
    {
        while (i < j&&arr[j] >= tmp)
            j--;
        if (i < j)
        {
            arr[i] = arr[j];
            i++;
        }

        while (i < j&&arr[i] < tmp)
            i++;
        if (i < j)
        {
            arr[j] = arr[i];
            j--;
        }
    }

    arr[i] = tmp;

    quickSort(arr, start, i - 1);
    quickSort(arr, i + 1, end);

}

//将两个有序数列a[first...mid]和a[mid+1...last]合并。
void mergeArray(int a[], int first, int mid, int last, int temp[])
{
    int i = first;    // 第一个有序序列的开始下标
    int j = mid + 1;    // 第2个有序序列的开始下标

    int length = 0;
    // 合并两个有序序列
    while (i <= mid && j <= last)
    {
        // 找二者中比较小的数
        if (a[i] < a[j])
        {
            temp[length] = a[i];
            i++;
        }
        else
        {
            temp[length] = a[j];
            j++;
        }
        length++;
    }
    // 还剩下一个有序序列中有数据
    while (i <= mid)
    {
        temp[length] = a[i];
        i++;
        length++;
    }
    while (j <= last)
    {
        temp[length++] = a[j++];
    }

    // 覆盖原来位置的无序序列
    for (int i = 0; i < length; ++i)
    {
        // 找到原来 的第一个有序序列的开始位置 - 开始覆盖
        a[first + i] = temp[i];
    }
}
//归并排序
void mergeSort(int a[], int first, int last, int temp[])
{
    // 递归结束的条件
    if (first == last)
    {
        return;
    }
    // 从中间位置拆分
    int mid = (first + last) / 2;
    // 拆分
    // 左半边
    mergeSort(a, first, mid, temp);
    // 右半边
    mergeSort(a, mid + 1, last, temp);
    // 合并两个有序序列
    mergeArray(a, first, mid, last, temp);
}

//堆排序
void heapSort(int arr[], int arrSize)
{
    int heapSize = buildHeap(arr, arrSize);
    while (heapSize > 1)
    {
        swap(arr, 0, --heapSize);
        heap(arr, 0, heapSize);
    }

}
//建堆
int buildHeap(int arr[], int arrSize)
{
    int heapSize = arrSize;
    for (int i = heapSize / 2 - 1; i >= 0; i--)
        heap(arr, i, heapSize);
    return heapSize;
}
//从指定节点开始向下进行堆调整
void heap(int arr[], int i, int size)
{
    int leftChild = 2 * i + 1;
    int rightChild = 2 * i + 1;
    int max = i;

    if (leftChild<size&&arr[leftChild]>arr[max])
        max = leftChild;
    if (rightChild<size&&arr[rightChild]>arr[max])
        max = rightChild;
    if (max != i)
    {
        swap(arr, i, max);
        heap(arr, max, size);
    }
}

　　排序算法的稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，则称这种排序算法是稳定的；否则称为不稳定的。

　　源码地址：https://github.com/MasterMeng/sort