九大封神排序算法（更新中）

排序算法

时间复杂度O(n**2)

冒泡排序

排序思想：一边比较一边向后两两交换，将最大值 / 最小值冒泡到最后一位

/*
	thought for code:
		冒泡排序要交换n-1次,这是第一层循环
		在每一次交换中都会把最大的数放到最右边,此时最右边这个数便不用参加排序了
		因此，第二层循环的条件是-i
*/
int array[] = { 4, 3, 5, 1 }, temp = 0;
for (int i = 0; i < sizeof(array) / sizeof(array[0]) - 1; i++) {
    for (int j = 0; j < sizeof(array) / sizeof(array[0]) - 1 - i; j++) {
        if (array[j] > array[j + 1]) {
            temp = array[j + 1];
            array[j + 1] = array[j];
            array[j] = temp;
        }
    }
}

选择排序

选择排序：双重循环遍历数组，每经过一轮比较，找到最小元素的下标，将其交换至首位

/*
	thought for code:
		选择排序从前向后依次遍历，找到每个下标对应的最小元素值
		第一层循环是各自找出每个下标的位置
		第二层循环是找出对应下标的最小元素值
		因为其前面肯定是比她小,以只用考虑后面即可
		找到其后面的最小值的下标，交换即可
*/
for (int i = 0; i < 3; i++) {
    int minValIndex = i;
    for (int j = i + 1; j < 4; j++) {
        if (array[minValIndex] > array[j]) {
            minValIndex = j;
        }
    }
    temp = array[i];
    array[i] = array[minValIndex];
    array[minValIndex] = temp;
}

冒泡排序法是稳定的，选择排序法是不稳定的
什么是稳定？假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变。
冒泡排序中，只有左边的数字大于右边的数字时才会发生交换，相等的数字之间不会发生交换，所以它是稳定的。
而选择排序中，最小值和首位交换的过程可能会破坏稳定性。比如数列：[2, 2, 1]，在选择排序中第一次进行交换时，原数列中的两个 2 的相对顺序就被改变了，因此，我们说选择排序是不稳定的

插入排序

插入排序：在新数字插入过程中，与前面的数字不断比较，前面的数字不断向后挪出位置，当新数字找到自己的位置后，插入一次即可（移动法）

/*
	thought for code:
		依次遍历每个元素,和她前面的元素进行比较，如果小于前面的元素就把前面的元素后移
		直到她大于她前面的元素(j),此时就将这个位置(j + 1)赋值本元素
*/
for (int i = 1; i < 4; i++) {
    int currentVal = array[i];
    int j = i - 1;
    while (j >= 0 && currentVal < array[j]) {
        array[j + 1] = array[j];
        j--;
    }
    array[j + 1] = currentVal;
}

插入排序是一种稳定的排序算法

时间复杂度O(nlogn)

希尔排序

希尔排序是不稳定的

算了太拉了，不想讲解

堆排序

堆排序：

• 用数列构建出一个大顶堆，取出堆顶的数字；
• 调整剩余的数字，构建出新的大顶堆，再次取出堆顶的数字；
• 循环往复，完成整个排序。

根节点的值 ≥ 子节点的值，这样的堆被称之为最大堆，或大顶堆；
根节点的值 ≤ 子节点的值，这样的堆被称之为最小堆，或小顶堆；

快速排序

快速排序：

• 从数组中取出一个数，称之为基数（pivot）
• 遍历数组，将比基数大的数字放到它的右边，比基数小的数字放到它的左边。遍历完成后，数组被分成了左右两个区域
• 将左右两个区域视为两个数组，重复前两个步骤，直到排序完成

void quickSort(int* array, int start, int end) {
    if (start >= end) {
        return;
    }
    int middle = partition(array, start, end);
    quickSort(array, start, middle - 1);
    quickSort(array, middle + 1, end);
}
int partition(int* array, int start, int end) {
    int pivot = array[start];
    int left = start + 1;
    int right = end;
    while (left < right) {
        while (left < right && array[left] < pivot) {
            left++;
        }
        if (left != right) {
            swap(array, left, right);
            right--;
        }
    }
    if (left == right && array[right] > pivot) {
        right--;
    }
    if (start != right) {
        swap(array, start, right);
    }
    return right;
}
void swap(int* array, int m, int n) {
    int temp = array[m];
    array[m] = array[n];
    array[n] = temp;
}

不稳定的排序算法