排序算法

/*
 * 排序：冒泡排序
 * 平均时间复杂度：O(n*n)
 * 最坏时间复杂度：O(n*n)
 * 空间复杂度：O(1)
 * 稳定性：稳定
 * 思路:它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
 *      走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
 *      每一次i的循环就是找到最小的那个数
 * */
void SortAlgorithm::bubbleSort(vector<int> A) {
    int size = A.size();
    if (size < 2) {
        return;
    }
    for (int i = 0; i < size - 1; i++) {
        for (int j = i + 1; j < size; j++) {
            if (A[i] > A[j]) {
                swap(A[i], A[j]);
            }
        }
    }
}

/*
 * 排序：选择排序
 * 平均时间复杂度：O(n*n)
 * 最坏时间复杂度：O(n*n)
 * 空间复杂度：O(1)
 * 稳定性：不稳定  由于每次会有交换所以会导致不稳定  eg：4 2 4 1 第一次交换是第一个4和1交换 导致不稳定
 * 思路:每一次找到最小的那个数  交换当前没有排序的最前面的位置
 * */
void SortAlgorithm::selectionSort(vector<int> A) {
    int size = A.size();
    if (size < 2) {
        return;
    }
    for (int i = 0; i < size - 1; i++) {
        int indexMin = i;
        for (int j = i + 1; j < size; j++) {
            if (A[j] < A[indexMin]) {
                indexMin = j;
            }
        }
        if (i != indexMin) {
            swap(A[indexMin], A[i]);
        }
    }
}

/*
 * 排序：直接插入排序
 * 平均时间复杂度：O(n*n)
 * 最坏时间复杂度：O(n*n)
 * 空间复杂度：O(1)
 * 稳定性：稳定
 * 思路: 插入排序就是后面的元素当成新的元素,插入已经排序好的序列里面
 * */
void SortAlgorithm::straightInsertionSort(vector<int> A) {
    int size = A.size();
    if (size < 2) {
        return;
    }
    for (int i = 1; i < size; i++) {
        if (A[i - 1] > A[i]) {
            int temp = A[i], j;
            for (j = i - 1; j >= 0 && A[j] > temp; j--) {
                A[j + 1] = A[j];
            }
            A[j + 1] = temp;
        }
    }
}

/*
 * 排序：快速排序
 * 平均时间复杂度：O(nlogn)
 * 最坏时间复杂度：O(n*n)
 * 空间复杂度：0(logn)
 * 稳定性：不稳定
 * 思路：通过哨兵的操作 把数组分成 左右两个 把数组的左边的第一个数当成基数  然后从右边开始 右边找比基数小的数 左边找比基数大的数
 *      在left<right的时候找到了就交换位置 最后交换左右碰面和基数的位置  就保证了基数左面的数一定小于基数  基数右边的数一定大于基数
 *      然后递归 基数左边的  基数右边
 * */
void SortAlgorithm::quickSort(int a[], int low, int high) {
    if (low >= high) {
        return;
    }
    int first = low;
    int last = high;
    int key = a[first];

    while (first < last) {
        while (first < last && a[last] >= key) {
            --last;
        }
        a[first] = a[last];
        while (first < last && a[first] <= key) {
            ++first;
        }
        a[last] = a[first];
    }
    a[first] = key;
    quickSort(a, low, first - 1);
    quickSort(a, first + 1, high);
}