排序算法总结（一）

各排序算法比较

1. 冒泡排序

时间复杂度： O(n2)
空间复杂度： O(1)
冒泡排序法过程并不包括原始数据的存储过程，所以空间复杂度是 O(1)而不是O(n)。
稳定性：稳定
步骤：
1、比较相邻的元素。如果第一个比第二个大（小），就交换他们两个。
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大（小）的数。
3、针对所有的元素重复以上的步骤，除了最后已经选出的元素（有序）。
4、持续每次对越来越少的元素（无序元素）重复上面的步骤，直到没有任何一对数字需要比较，则序列最终有序。

void sort(int *a, int len){
	int i, j, temp;
    for (i = 0; i < len; i++){
        for (j = 0; j < len - i - 1; j++){
            if (a[j] > a[j + 1]){
                temp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = temp;
            }
        }
    }
}

2.快速排序

时间复杂度：平均为O(nlog(n)) 最差情况为O(n2)
空间复杂度：O(log(2n)) ~ O(n)
稳定性：不稳定
步骤：

1. 先从数列中取出一个数作为基准数。
2. 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3. 再对左右区间重复第二步，直到各区间只有一个数。

void QuickSort(int *arr, int low, int high){
    if (low < high){
        int i = low;
        int j = high;
        int k = arr[low];
        while (i < j){
            while(i < j && arr[j] >= k){     // 从右向左找第一个小于k的数
                j--;
            }
            if(i < j){
                arr[i++] = arr[j];
            }
            while(i < j && arr[i] < k){      // 从左向右找第一个大于等于k的数
                i++;
            }
            if(i < j){
                arr[j--] = arr[i];
            }
        }
        arr[i] = k;
        // 递归调用
        QuickSort(arr, low, i - 1);     // 排序k左边
        QuickSort(arr, i + 1, high);    // 排序k右边
    }
}
 

3.选择排序

时间复杂度：O(n2)
空间复杂度：O(1)
稳定性：不稳定
步骤：选出最小的数，放在第一个位置；然后，选出第二小的数，放在第二个位置；以此类推，直到所有的数从小到大排序。在实现上，我们通常是先确定第i小的数所在的位置，然后，将其与第i个数进行交换。

void select_sort(int a[],int n){//n为数组a的元素个数
    int i, j, temp;
    //进行N-1轮选择
    for (i = 0; i < n - 1; i++){
        int min_index = i; 
        //找出第i小的数所在的位置
        for (j = i + 1; j < n; j++){
            if (a[j] < a[min_index]){
                min_index = j;
            }
        }
        //将第i小的数，放在第i个位置；如果刚好，就不用交换
        if (i != min_index){
            temp = a[i];
            a[i] = a[min_index];
            a[min_index] = temp;
        }
    }
}

4.直接插入排序

步骤：从第二个元素“i”开始缓存准备用于比较,并留出一个空位将空位前的元素“j”拿来与缓存值比较不满足则移动,直到向前找到头比较的目的是要让缓存值插入后成为从开头到插入点这个区间中的最值如果缓存值向前看不是最值，则往后移动，直到可以让缓存值插入后成为最值时停止将缓存值插入到最值位置(即内循环下一个将要移动的位置)。

void InsertSort(int *a, int n){
	int i, j;
    for (i = 1; i < n; i++){
        if (a[i] < a[i - 1]){//若第 i 个元素大于 i-1 元素则直接插入；反之，需要找到适当的插入位置后在插入。
            j = i - 1;
            int x = a[i];
            while(j > -1 && x < a[j]){  //采用顺序查找方式找到插入的位置，在查找的同时，将数组中的元素进行后移操作，给插入元素腾出空间
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = x;      //插入到正确位置
        }
    }
}

5.归并排序

步骤：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针到达序列尾
5. 将另一序列剩下的所有元素直接复制(抄)到合并序列尾

void merge(int arr[], int low, int mid, int high){
    int i, k;
    int *tmp = (int *)malloc((high-low+1)*sizeof(int));
    //申请空间，使其大小为两个
    int left_low = low;
    int left_high = mid;
    int right_low = mid + 1;
    int right_high = high;

    for(k=0; left_low<=left_high && right_low<=right_high; k++){  // 比较两个指针所指向的元素
        if(arr[left_low]<=arr[right_low]){
            tmp[k] = arr[left_low++];
        }else{
            tmp[k] = arr[right_low++];
        }
    }

    if(left_low <= left_high){  //若第一个序列有剩余，直接复制出来粘到合并序列尾
    //memcpy(tmp+k, arr+left_low, (left_high-left_low+l)*sizeof(int));
    for(i=left_low;i<=left_high;i++)
        tmp[k++] = arr[i];
    }

    if(right_low <= right_high){
    //若第二个序列有剩余，直接复制出来粘到合并序列尾
    //memcpy(tmp+k, arr+right_low, (right_high-right_low+1)*sizeof(int));
        for(i=right_low; i<=right_high; i++)
            tmp[k++] = arr[i];
    }

    for(i=0; i<high-low+1; i++)
        arr[low+i] = tmp[i];
    free(tmp);
    return;
}

void merge_sort(int arr[], unsigned int first, unsigned int last){
    int mid = 0;
    if(first<last){
        mid = (first+last)/2; /* 注意防止溢出 */
        /*mid = first/2 + last/2;*/
        //mid = (first & last) + ((first ^ last) >> 1);
        merge_sort(arr, first, mid);
        merge_sort(arr, mid+1,last);
        merge(arr,first,mid,last);
    }
    return;
}

6.桶排序

1.设置一个定量的数组当作空桶子。
2.寻访序列，并且把项目一个一个放到对应的桶子去。
3.对每个不是空的桶子进行排序。
4.从不是空的桶子里把项目再放回原来的序列中。

#define Max_len 10      //数组元素个数

int GetMaxVal(int* arr, int len){
    int maxVal = arr[0]; //假设最大为arr[0]

    for(int i = 1; i < len; i++)  //遍历比较，找到大的就赋值给maxVal
    {
        if(arr[i] > maxVal)
            maxVal = arr[i];
    }
    
    return maxVal;  //返回最大值
}

//桶排序   参数：数组及其长度

void BucketSort(int* arr , int len){
    int tmpArrLen = GetMaxVal(arr , len) + 1;
    int tmpArr[tmpArrLen];  //获得空桶大小
    int i, j;

    for(i = 0; i < tmpArrLen; i++)  //空桶初始化
        tmpArr[i] = 0;
    for(i = 0; i < len; i++)   //寻访序列，并且把项目一个一个放到对应的桶子去。
        tmpArr[ arr[i] ]++;
    for(i = 0, j = 0; i < tmpArrLen; i ++){
        while( tmpArr[ i ] != 0) //对每个不是空的桶子进行排序。
        {
            arr[j ] = i;  //从不是空的桶子里把项目再放回原来的序列中。
            j++;
            tmpArr[i]--;
        }
    }
}

7.堆排序

步骤一：建立大根堆–将n个元素组成的无序序列构建一个大根堆，
步骤二：交换堆元素–交换堆尾元素和堆首元素，使堆尾元素为最大元素；
步骤三：重建大根堆–将前n-1个元素组成的无序序列调整为大根堆
重复执行步骤二和步骤三，直到整个序列有序。

#include<iostream>
#include<vector>
using namespace std;
 
// 递归方式构建大根堆(len是arr的长度，index是第一个非叶子节点的下标)
void adjust(vector<int> &arr, int len, int index)
{
    int left = 2*index + 1; // index的左子节点
    int right = 2*index + 2;// index的右子节点
 
    int maxIdx = index;
    if(left<len && arr[left] > arr[maxIdx])     maxIdx = left;
    if(right<len && arr[right] > arr[maxIdx])     maxIdx = right;
 
    if(maxIdx != index)
    {
        swap(arr[maxIdx], arr[index]);
        adjust(arr, len, maxIdx);
    }
 
}
 
// 堆排序
void heapSort(vector<int> &arr, int size)
{
    // 构建大根堆（从最后一个非叶子节点向上）
    for(int i=size/2 - 1; i >= 0; i--)
    {
        adjust(arr, size, i);
    }
 
    // 调整大根堆
    for(int i = size - 1; i >= 1; i--)
    {
        swap(arr[0], arr[i]);           // 将当前最大的放置到数组末尾
        adjust(arr, i, 0);              // 将未完成排序的部分继续进行堆排序
    }
}
 
int main()
{
    vector<int> arr = {8, 1, 14, 3, 21, 5, 7, 10};
    heapSort(arr, arr.size());
    for(int i=0;i<arr.size();i++)
    {
        cout<<arr[i]<<endl;
    }
    return 0;
}