数据结构与算法-冒泡排序

排序基础概念

排序的稳定性

定义：排序前，有排序关键字相同的两条记录，这两条记录有先后顺序，如果排序后，这个顺序依旧不变，为稳定排序；否则为不稳定排序。

内排序和外排序

定义：内排序是在排序过程中，待排序的记录都放在内存中的排序。外排序是待排序数据太大，无法都放入内存，排序过程中需要不断交换内存和外部存储。

对内排序来说，排序算法的性能主要受三方面影响：

• 时间性能
• 辅助空间
• 算法本身复杂性

冒泡排序

算法核心

• 如果是升序排序，从后往前，每次轮转都把 两两比较的 **相对较小值 ** 冒泡到数组的小端
• 如果是降序排序，从后往前，每次轮转都把 两两比较的 相对较大值 冒泡到数组的小端
  

算法实现关键

• 两层循环，外层正序
• 内层循环从后往前，循环结束点依次增大
• 优化点：加入判断轮次内从未交换flag，如果从未交换，直接结束排序

c实现

#include <stdio.h>
#include <cstring>
#include <cstdlib>

#define MAXSIZE 10

typedef struct {
    int r[MAXSIZE];
    int length;
} SqList;

/**
 * 交换函数
 * @param list
 * @param i
 * @param j
 */
void swap(SqList *list, int i, int j) {
    int tmp = list->r[i];
    list->r[i] = list->r[j];
    list->r[j] = tmp;
}

/**
 * 冒泡排序-从小到大
 * @param list
 */
void BubbleSortASC(SqList *list) {
    int length = list->length;
    for (int i = 0; i < length; ++i) {
        for (int j = length - 1; j >= i + 1; j--) {
            if (list->r[j] < list->r[j - 1]) {
                swap(list, j, j - 1);
            }
        }
    }
}

/**
 * 冒泡排序-从小到大 优化版
 * @param list
 */
void BubbleSortASCoptimization(SqList *list) {
    int length = list->length;
    for (int i = 0; i < length; ++i) {
        bool flag = false;
        for (int j = length - 1; j >= i + 1; j--) {
            if (list->r[j] < list->r[j - 1]) {
                swap(list, j, j - 1);
                flag = true;
            }
        }
        if (!flag) {
            break;
        }
    }
}

int main() {
    SqList sqList = SqList();
    //初始化赋值
    for (int i = 0; i < MAXSIZE; ++i) {
        sqList.r[i] = rand();
    }
    sqList.length = MAXSIZE;
    //排序
    //BubbleSortASCoptimization(&sqList);
    //排序
    BubbleSortASC(&sqList);

    for (int i = 0; i < MAXSIZE; ++i) {
        printf("%d
", sqList.r[i]);
    }
}

记忆口诀

两层循环，外层正序，内层从后往前，两两比较