八大排序算法（基于C++）

为了和其他的博客差不多，还是放一张对比图把，因为上个礼拜复习排序的时候找的代码良莠不齐，所以总结了一下，C++自己写了一份，我是认为 堆排序、快速排序 、归并排序是比较难懂的，感觉面试问的比较多

冒泡排序 时间复杂度 O(N2)
稳定的
算法原理：
1 、比较相邻的元素，如果第一个比第二个大，就交换
2 、 对每一对相邻的元素，从第一对到结尾的最后一对，最大的数到了数组最后
3、

//冒泡排序  时间复杂度 O2
void bubbleSort(vector<int>& a){
	int n = a.size();
    int i, j;
    for(int i = 0 ; i < n; i ++){
        for(int j = 0 ; j < n - i ; j++){   
            if(a[j] > a[j+1]){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

 
 
快速排序 事件复杂度 O(nlogn)

 
  当 low >= high 的时候，返回， i < j ，从最右边开始寻找 第一个 小于 key的数字，之后将这个数字 赋值给 a[i] ，可以理解为这个第 j 位空了，再从左边向右边找，找到第一个大于 key 的数字，并把这个 a[i] 赋值给 上一个的 第 j 个 空位，这里必须要有 i<j 这个限制，不然如果最左边数字很小，比如 -100000000 ，那么在执行 while(a[j] >= key && i < j) 这一步的时候， j 会一直减下去，
  正常情况下，a[i] 赋值给了 a[j] ，这时候相当于 i 位 又空了，循环结束之后， 用分隔的关键值 key 去补充 i 位数，于是 i 就当作了一个中间数字，左边的数字都比它小，右边的数字都比它大，再次进入下面的 low i 范围 和 i+1 high 范围进行递归 最终完成排序。

/*
/*@brief 快速排序
    冒泡 + 分治 + 递归
 *
 */
void quickSort(int a[], int low, int high){
    if(low >= high)
        return;
    int i = low;  // i 作为指针从左向右扫描
    int j = high; 
    int key = a[low];
    while(i<j){
        while(a[j] >= key && i < j)   //右边小于基准的数字
            j--;
        a[i] = a[j];
        while(a[i] <= key && i < j) //左边大于基准的数字
            i++;
        a[j] = a[i];
    } 
    a[i] = key;   // 当i与j相遇，将基准元素赋值到指针 i 处
    quickSort(a, low, i);
    quickSort(a, i+1, high);

}

 
 
堆排序 ，事件复杂度 nlogn
这里建堆的时候是大顶堆，之后排序的时候每次大顶堆都跟数组末尾最后一个交换，所以最后得到的顺序是升序排列

/*
 *@  堆排序
 */
void adjust_heap(int *a, int root, int  len){
    int left = 2*root + 1;
    int right = 2*root + 2;
    int max = root;
    
    if(left < len && a[left] > a[max])   // left < len 防止越界
        max = left;
    if(right < len && a[right] > a[max])
        max = right;
    if(max != root){
        swap(a[max], a[root]);   //堆顶需要最大
        adjust_heap(a, max, len);
    }
}

void heap_sort(int *a, int len){
    //初始化建堆
    for(int i = len/2-1 ; i >= 0; --i){  //从最后一个非叶子节点开始向前进行调整
        adjust_heap(a, i, len);
    }
  
    //排序重建堆
    cout << a[0] << endl;
    for(int i = len-1 ; i >= 0; --i){   //堆排序 此时 [0, len-1]为一个堆
        swap(a[0], a[i]);
        adjust_heap(a, 0, i);
    }

}

 
 
 
 
归并排序
事件复杂度 O(nlogn)
稳定
分治 递归 再合并，其中递归会会消耗掉大量的时和空间

 
  这里要消耗掉额外的O(N) 的空间，首先是主要函数MergeSort，先计算出 middle的数值，之后分开计算 [left, middle] 和 [middle + 1, right] ，这里我用的是左闭右闭的空间，对于主函数 MergeSort 来说，会不断的进行递归，直到 最后一个left > right 为止，这时候进入 Merge函数，在Merge函数中，参数要有 left 、 middle 、right ，先用一个辅助数组将数组的值 copy 下来，在这之前，将left赋值给 i ，将 middle+1 赋值给 j ，相当于变成了两个数组，[ 0 , i ] 和 [ j , right ] 然后进入循环，从 left 到 right ，以 middle 为界分成两边，如果 i 超过了middle，就直接将右边数组 放进nums ，同理，如果 j 已经超过了 right ，直接将左边数组元素 放进 nums中，因为当 左边大于右边是，放入右边，同时右边 ++ ，右边大于左边时候，放入左边，左边 ++

/*
 *@brief 归并排序
 *@   分治  递归会占用大量的时间和空间  合并
 */
//合并数组中的下标为 left 到 middle ，  middle到right
void Merge(vector<int>& nums, int left, int middle, int right){
    int temp[right-left+1];   //分配辅助数组
    for(int i = left ; i <= right ; i++)
        temp[i-left] = nums[i];  //给临时数组赋值  temp成为一个和arr一样的数组

    int i = left, j = middle + 1;   //i 指向左边第0个， j指向右边第0个
    
    for(int k = left ; k <= right ; k++){
        if(i > middle && j <= right){ // i 超过了 middle  所以直接放右边数组数字
            nums[k] = temp[j - left];
            j++; 
        }
        else if(j > right && i <= middle){  //  j 已经超过了 right  所以直接放 左边数组数字
            nums[k] = temp[i - left];
            i++;
        }
        else if(temp[i - left] > temp[j - left]){  // 左边大于右边
            nums[k] = temp[j-left];
            j++;
        }
        else if(temp[i-left] < temp[j-left]){  //右边大于左边
            nums[k] = temp[i-left];
            i++;
        }
    }

}

void MergeSort(vector<int>& nums, int left, int right){
    if(left >= right)
        return;
    
    int middle = (right+left)/2;

    MergeSort(nums, left, middle);
    MergeSort(nums, middle+1, right);

    Merge(nums, left, middle, right);
     
  
}

 
 

选择排序
时间复杂度 O(n2)
直接选择排序

//选择排序  时间复杂度 O2     不稳定   
void selectSort(int a[], int n){
    int i,j,index;
    for(int i = 0 ; i < n-1 ; i++){
        index = i;
        for(int j = i+1 ; j < n ; j++){
            if(a[index]  > a[j])
                index = j;
            swap(a[index], a[i]);
            
        }
    }
}

 
 
插入排序 稳定的
时间复杂度 O(n2)
直接插入排序
 
  这里我们首先 从第一位开始，将 a[i] 赋值给 key，再 设置 j = i-1 , 之后就是在 0 ~ j 之间，j 是 减减的，那么当 a[j] 大于 key 的时候，也就说明在 i 位数之前 (不包括i位数) 的 0~j 中有大于 a[i] 的值出现，这时候将 a[j] 赋值给 a[j+1] ，这里值得注意的点是，j 是 赋值 给 j+1，j 减减之后，如果向前再次找到有大于 key 的 数值，j 位 将数值 赋值给 j+1 ，不必疑惑的是，这一位大还是先前 上一轮 循环里 赋给 j+1 的数值大，因为从 1 开始的话，之后的每一次对于 j 的for 循环，j 在 i 之前一位，可以认为 i 之前的序列都已经排好序列了，事实上也正是如此，所以随着 j减减 的操作，当出现某一个 j 位置的数字(a[j]) <= key 的时候，跳出 j 的循环，此时记录了 j 的位置
  对于这一个关键位置的 j 来说，上一轮循环中，j 位置的数字(a[ j ]) 是大于key的，a[j] 赋值给了 a[j+1]，相当于 j 的位置空了，再次循环，j做出减减的操作，这时候可以得到 j+1 实际上是空的那一位，此时的 a[j] 符合 a[j]<=key ，执行 break 跳出循环，key 作为一个切割的关键值，将key 赋值给空位置，a[j+1] = key ，如此循环，最后得到有序序列。

/*@brief 插入排序
 *
 */
void insertSort(int a[], int n){
    int i,j,key;
    for(int i = 1; i < n ; i++){
        key = a[i];
        j = i - 1;
        for(j ; j >= 0 ;j--){
            if(a[j] > key)
                a[j+1] = a[j];
            else
                break;
        }
        a[j+1] = key;
    }
}

 
 

希尔排序

 
 

基数排序