C++ 选择排序、冒泡排序、插入排序

选择排序：是一种简单直观的排序算法，每次均是选择最小（大）的元素进行排序。

选择排序算法思想：1 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

2 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾

重复第2步，直到排序完成、时间复杂度为 n^2 空间复杂度为 1

这种算法的优点是时间复杂度高，并且会改变相同元素的相对位置，因此这个是一种不稳定的排序算法

代码练习1，对应力扣颜色分类，代码见下

cpp 复制代码

class Solution {
public:
    void selectionSort(vector<int>& a){
        int n = a.size();
        for(int i = 0; i<n; ++i){
            int min = i;
            for(int j = i+1; j<n; ++j){
                if(a[min] > a[j]){
                   min = j; 
                }
            }
            int tmp = a[min];
            a[min] = a[i];
            a[i] = tmp;
        }
    } 
    void sortColors(vector<int>& nums) {
        selectionSort(nums);
    }
};

冒泡排序：是一种简单的排序算法，通过多次比较和交换相邻的元素，将数组中的元素按升序或降序排列

冒泡排序的算法思想：

1 遍历数组的第一个元素到最后一个元素

2 对每一个元素，与后一个元素进行比较

3 如果顺序错误，就将他们交换

重复上述步骤，直至数组中的所有元素至少被遍历过一次

冒泡排序的时间复杂度为0(n^2)，空间复杂度为0(1)

冒泡排序的算法优点：是一种稳定的算法，不会改变相同元素的相对位置，缺点便是效率低下，时间复杂度较高

代码一，对应力扣，合并两个有序数组，代码见下

cpp 复制代码

class Solution {
    void bubbleSort(vector<int>& a){
        int n = a.size();
        for(int i = n-1; i>=0; --i){
            for(int j=0; j<i; ++j){
                if(a[j] > a[j+1]){
                    int tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                }
            }
        }

    }
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        for(int i=0; i<nums2.size(); ++i){
            nums1[m+i] = nums2[i];

        }
        bubbleSort(nums1);
    }
};

代码2 对应力扣，最后一块石头的重量，代码见下：

cpp 复制代码

class Solution {
    void bubbleSort(vector<int>& a){
        int n = a.size();
        for(int i=n-1; i>=0; --i){
            for(int j=0; j<i; ++j){
                if(a[j] > a[j+1]){
                    int tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                }
            }
        }

    }
public:
    int lastStoneWeight(vector<int>& stones) {
        while(stones.size() > 1){
            bubbleSort(stones);
            int n = stones.size();
            int v = stones[n-1] - stones[n-2];
            stones.pop_back();
            stones.pop_back();
            if(v || stones.size() == 0){
                stones.push_back(v);
            }
        }
        return stones[0];
    }
};

插入排序：工作原理是通过构建有序序列，对于未排序序列，在已排序序列中从后往前扫描，找到对应位置插入，从而使得有序。

算法步骤：1 从第一个元素开始，将它视为已排序部分

2 取出下一个元素，与已排序的元素进行比较

3 如果该元素小于已排序部分的最后一个部分，则将其插入到已排序部分的适当位置，重复 2和3直到完成排序

插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)

代码练习 1，对应力扣，去掉最低工资和最高工资后的工资平均值，代码见下

cpp 复制代码

class Solution {
    void insertSection(vector<int>& a){
        for(int i=1; i<a.size(); ++i){
            int x = a[i];
            int j;
            for( j=i-1; j>=0; --j){
                if(x < a[j]){
                    a[j+1] = a[j];
                }else{
                    break;
                }
            }
            a[j+1] = x;
        }
    }
public:
    double average(vector<int>& salary) {
        insertSection(salary);
        int n = salary.size();
        double sum = 0;
        for(int i=1; i<n-1; ++i){
            sum += salary[i];
        }
        return sum / (n-2);
    }
};

代码 2，对应力扣删除某些元素后的数组均值，代码见下

cpp 复制代码

class Solution {
    void insertionSort(vector<int>& a){
        for(int i=1; i<a.size(); ++i){
            int x = a[i];
            int j;
            for(j=i-1; j>=0; --j){
                if(x < a[j]){
                    a[j+1] = a[j];
                }else{
                    break;
                }
            }
            a[j+1] = x;
        }
    }
public:
    double trimMean(vector<int>& arr) {
        insertionSort(arr);
        int n = arr.size();
        double sum = 0;
        int cnt = 0;
        for(int i = n/20; i<n-n/20; ++i){
            sum += arr[i];
            cnt++;
        }
        return sum/cnt;
    }
};

代码 3，学生分数的最小差值，代码见下

cpp 复制代码

class Solution {
    void insertionSort(vector<int>& a){
        for(int i=1; i<a.size(); ++i){
            int x = a[i];
            int j;
            for(j=i-1; j>=0; --j){
                if(x < a[j]){
                    a[j+1] = a[j];
                }else{
                    break;
                }
            }
            a[j+1] = x;
        }
    }
public:
    int minimumDifference(vector<int>& nums, int k) {
        insertionSort(nums);
        int ret = 100000000;
        for(int i=0; i + k - 1 < nums.size(); ++i){
            int l = i;
            int r = i + k - 1;
            ret = min(ret, nums[r] - nums[l]);
        }
        return ret;
    }
};