七种排序算法总结，包括代码，注释，性能。

准备工作面试啊，写代码的总要知道这些东西，免得面试一问三不知，过不了。欢迎纠错与指教！！！

/*排序算法总结(按升序排序)*/

#include "stdafx.h"
#include "iostream"
#include
using namespace std;
//稳定性是描述排序后，原有序序列是否发生变化。变化则不稳定

/**************************
函数  功能：冒泡排序
时间复杂度：O(n^2)
空间复杂度：O(1)
稳  定  性：稳定
**************************/
void BubbleSort(int a[],int N)
{
    int temp;

    for (int i = 0;i < N;i++)//从头开始遍历，把大的依次移到后面
    {
        for (int j = 0;j < N - i-1;j++)//到最后一位的是最大的，倒数第二个是第二大的以此类推。
        {
            if (a[j] > a[j + 1])
            {
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }

}

/**************************
函数  功能：插入排序
时间复杂度：O(n^2)
空间复杂度：O(1)
稳  定  性：稳定
**************************/
void InsertSort(int a[], int N)
{
    int temp,j;
    for (int i = 1;i < N;i++)//从前向后扫描，记下当前值
    {
        temp = a[i];
        int k=i;
        for (j = i-1;j >= 0&& a[j] > temp;j--)//再次往前遍历，遍历值与当前值做比较，做移位处理
        {
            a[j + 1] = a[j];        
        }
        a[j+1] = temp;//最后将当前值(j相对于循环发生的J已经减小了1)填充上去

    }
}

/**************************
函数  功能：选择排序
时间复杂度：O(n^2)
空间复杂度：O(1)
稳  定  性：不稳定
**************************/
void selectionSort(int a[],int N)
{
    int temp;
    for (int i = 0;i < N;i++)//从头开始遍历，记录当前遍历值遍历过的就是有序区域
    {
        temp = a[i];
        int k = i;
        for (int j = i;j < N;j++)//在无序区找到最小的和当前遍历值进行交换
        {
            if (a[j] < temp)
            {
                temp = a[j];
                k = j;
            }
        }
        temp = a[i];
        a[i] = a[k];
        a[k] = temp;
    }
}

/**************************
函数  功能：希尔排序
时间复杂度：O(N(logN)^2)
空间复杂度：O(1)
稳  定  性：不稳定
**************************/
void shellSort(int a[],int N)
{
    int gap, temp;
    for (gap = N >> 1;gap > 0;gap>>=1)//步长先设置为数组长度的一半，依次减半
    {
        int i, j;
        for (i = gap;i < N;i++ )//插入排序
        {
            temp = a[i];
            for (j = i-gap;j>=0&& a[j] > temp;j-=gap)
            {           
                a[j + gap] = a[j];          
            }
            a[j+gap] = temp;
        }
    }
}

/**************************
函数  功能：归并排序
时间复杂度：O(NlogN)
空间复杂度：O(N)
稳  定  性：稳定
**************************/
void merge(int a[], int r[], int start, int end);
void mergeSort(int a[], const int N)
{
    int *r = new int[N];//创建新的空间来暂时存储数据
    merge(a, r, 0, N - 1);
    delete[] r;
}
void merge(int a[], int r[], int start, int end)
{
    if (start >= end)
        return;
    int len = end - start, mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;//分成两半
    merge(a, r, start1, end1);//分别归并
    merge(a, r, start2, end2);//分别归并
    int k = start;
    while (start1 <= end1 && start2 <= end2)//将两个有序的序列归并在一起
        r[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
    while (start1 <= end1)
        r[k++] = a[start1++];
    while (start2 <= end2)
        r[k++] = a[start2++];
    for (k = start; k <= end; k++)//将有序的序列传给当前的a数组
        a[k] = r[k];
}
/**************************
函数  功能：快速排序
时间复杂度：O(NlogN)
空间复杂度：O(logN)
稳  定  性：不稳定
**************************/
void quickSortRecursive(int a[], int start, int end) {
    if (start >= end) return;
    int mid = a[end];//选最后一个数作为基准
    int left = start, right = end - 1;
    while (left < right) {
        while (a[left] < mid && left < right) left++;//跳过左边比基准小的数
        while (a[right] >= mid && left < right) right--;//跳过右边比基准大的数
        swap(a[left], a[right]);//剩下来的一对就是左边比基准大，右边的比基准小，交换他们
    }
    if (a[left] >= a[end])//最靠近中间的位置的左边的数和这段的基准做比较（因为前面的循环跳过了这个比较）
        swap(a[left], a[end]);
    else
        left++;
    quickSortRecursive(a, start, left - 1);
    quickSortRecursive(a, left + 1, end);
}
void quickSort(int a[], int N) {
    quickSortRecursive(a, 0, N - 1);
}


/**************************
函数  功能：堆排序
时间复杂度：O(NlogN)
空间复杂度：O(1)
稳  定  性：不稳定
**************************/
//堆顶最大化
void max_heapify(int arr[], int start, int end) {
    int dad = start;
    int son = dad * 2 + 1;//按照二叉树的结构就知道父节点和子节点的关系了
    while (son <= end) { //
        if (son + 1 <= end && arr[son] < arr[son + 1]) //先比较两个子节点，选出最大的
            son++;
        if (arr[dad] > arr[son]) //如果父节点大于子节点就是调整完毕，跳出
            return;
        else { //否则父节点和子节点继续比较
            swap(arr[dad], arr[son]);
            dad = son;
            son = dad * 2 + 1;
        }
    }
}

void heap_sort(int arr[], int len) {
    //初始化，从最后一个父节点开始调整
    for (int i = len / 2 - 1; i >= 0; i--)//二叉树的模型，想想就知道节点的位置了
        max_heapify(arr, i, len - 1);
    //先将第一個元素和已经排好的元素前一位做交换，再重新调整(刚调整的元素之前的元素)，直到排序完
    for (int i = len - 1; i > 0; i--) {
        swap(arr[0], arr[i]);
        max_heapify(arr, 0, i - 1);
    }
}
int main()
{
    int a[] = { 3,2,4,6,5,8,0,1,6,9,2 };
    int N = 11;
    //BubbleSort(a, N);//冒泡排序
    //InsertSort(a, N);//插入排序
    //selectionSort(a, N);//选择排序
    //shellSort(a, N);//希尔排序
    //mergeSort(a, N);//归并排序
    //quickSort(a, N);//快速排序
    //heap_sort(a, N);//堆排序
    system("pasue");
    return 0;
}

一定要好好学习，提升自己！！！