冒泡排序，选择排序，插入排序

冒泡排序：

冒泡排序基本思想：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

时间复杂度：如果是按照优化后的算法来看，最优的就是已经有序，没有数据交换只有比较，时间复杂度是O(n).当最坏的情况，就是待排序表是逆序的情况，此时需要比较1+2+3+...+（n+1） = n（n-1） ／2 次，并坐等数量级的记录移动，总的时间复杂度为O(n^2).

实现代码：

// 2020/7/28 Python实现冒泡排序
a = [5, 9, 3, 4, 1, 7, 8, 6, 10, 2]

def bubble_sort(a):
    length = len(a)
    for i in range(length - 1):
        changed = False
        for j in range(length - 1 - i):
            if a[j] > a[j + 1]:
                changed = True
                tmp = a[j]
                a[j] = a[j + 1]
                a[j + 1] = tmp
        if changed is False:
            break
        print(a)
    return a


print(bubble_sort(a))

 

    int a[10] = {5,9,3,4,1,7,8,6,10,2};
    int temp;
    BOOL isChanged = NO;
    for (int i = 0; i <= 9; i++) {
        for (int j = 9 ; j > i ; j--) {
            if (a[j-1]<a[j]) {
                temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
                isChanged = YES;
            }
        }
        if (isChanged == NO) {
            break;
        }
    }

def quick_sort(b):
    if len(b) < 2:
        return b
    # 选取基准，随便选哪个都可以，选中间的便于理解
    mid = b[len(b) // 2]
    # 定义基准值左右两个数列
    left, right = [], []
    # 从原始数组中移除基准值
    b.remove(mid)
    for item in b:
        # 大于基准值放右边
        if item >= mid:
            right.append(item)
        else:
            # 小于基准值放左边
            left.append(item)
    # 使用迭代进行比较
    return quick_sort(left) + [mid] + quick_sort(right)


b = [11, 99, 33, 69, 77, 88, 55, 11, 33, 36, 39, 66, 44, 22]
print(quick_sort(b))

针对冒泡算法优化：

在二级for循环中增加bool值记录是否当前循环有移动数据，如果没有代表是已经有序的，不需要再浪费资源去遍历循环，停止。

选择排序

简单选择排序就是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i（1<=i<=n）个记录交换。

时间复杂度：O(n^2)，但是仍然优于冒泡排序。最大特点就是减少了交换移动数据次数相当少。

实现代码：

 

int a[10] = {5,9,3,4,1,7,8,6,10,2};
int min,temp;
for (int i = 0; i<9; i++) {
    min = i;
    for (int j = i+1; j<= 9; j++) {
        if (a[min] < a[j]) {
            min = j;
        }
    }
    if (min!=i) {
        temp = a[min];
        a[min] = a[i];
        a[i] = temp;
    }
}

插入排序：
直接插入排序的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录数增1的有序表。

 

时间复杂度：O(n^2)，但是还要逼选择排序性能要好一些。

实现代码：

 

    int a[10] = {5,9,3,4,1,7,8,6,10,2};
    int i,j;
    for (i = 2; i<=9; i++) {
        if (a[i] < a[i-1]) {
            a[0] = a[i];
            for (j =i - 1; a[j] > a[0]; j--) {
                a[j+1] = a[j];
            }
            a[j+1] = a[0];
        }
    }

 

根据排序过程中借助的主要操作，我们将内排序分为：插入排序，交换排序，选择排序和归并排序四类。

 

 

下图是7种算法的各种指标进行对比：

从算法的简单性来看，将7种算法分类：

简单算法：冒泡，简单选择，直接插入。

改进算法：希尔，堆，归并，快速。