冒泡排序及其改进算法：深入理解与实践_改进型的冒泡排序算法设计;

冒泡排序及其改进算法：深入理解与实践

冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止。

算法步骤

1. 比较相邻的元素。如果第一个比第二个大（升序排列），就交换它们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

伪代码

procedure bubbleSort( A : list of sortable items )
    n = length(A)
    repeat
        swapped = false
        for i = 1 to n-1 inclusive do
            if A[i-1] > A[i] then
                swap( A[i-1], A[i] )
                swapped = true
            end if
        end for
    until not swapped
end procedure
1
2
3
4
5
6
7
8
9
10
11
12

冒泡排序的改进

1. 优化的冒泡排序

在标准冒泡排序中，每次遍历至少会将一个元素放到它应该在的位置。因此，我们可以在每次遍历后，减少比较的元素数量，因为最后的元素已经是排序好的了。

2. 鸡尾酒排序（Cocktail Sort）

鸡尾酒排序，也称为双向冒泡排序，是冒泡排序的一种变体。它在每一轮排序中交替进行正向和反向的遍历，这样可以同时将最大的元素移动到数列的末端，以及最小的元素移动到数列的开头。

实现冒泡排序

以下是一个使用Python实现的冒泡排序示例：

def bubble_sort(arr):
    n = len(arr)
    # 优化的冒泡排序
    for i in range(n):
        # 初始化交换标志
        swapped = False
        # 最后i个元素已经是排序好的了，不需要再比较
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
                swapped = True
        # 如果没有发生交换，说明数组已经排序好了
        if not swapped:
            break
    return arr

# 鸡尾酒排序的实现
def cocktail_sort(arr):
    n = len(arr)
    swapped = True
    start = 0
    end = n - 1
    while swapped:
        swapped = False
        # 正向遍历
        for i in range(start, end):
            if arr[i] > arr[i + 1]:
                arr[i], arr[i + 1] = arr[i + 1], arr[i]
                swapped = True
        # 如果没有交换，说明数组已经排序好了
        if not swapped:
            break
        # 更新结束位置
        end -= 1
        # 反向遍历
        for i in range(end - 1, start - 1, -1):
            if arr[i] > arr[i + 1]:
                arr[i], arr[i + 1] = arr[i + 1], arr[i]
                swapped = True
        # 更新开始位置
        start += 1
    return arr

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
print("Original array:", arr)
print("Sorted array using Bubble Sort:", bubble_sort(arr.copy()))
print("Sorted array using Cocktail Sort:", cocktail_sort(arr.copy()))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

两数交换

先加后减

int a = 1,b = 2;
a = a + b;
b = a - b;
a = a - b;
1
2
3
4

先减后加

int a = 1,b = 2;
a = a - b;
a = a - b;
b = a + b;
1
2
3
4

但是可能会有数据溢出的情况，可以采用下面的小魔法来交换。

两数交换，不会溢出的小魔法

int a = 1,b = 2;
a = a ^ b;
b = b ^ a;
a = a ^ b;
1
2
3
4

结论

冒泡排序虽然在最坏情况下的时间复杂度为O(n^2)，但它的实现简单，对于小数据集或者基本有序的数据集，其性能表现还是相当不错的。通过优化和变体，我们可以提高冒泡排序的效率，使其在特定情况下更加实用。然而，对于大型数据集，更高效的排序算法（如快速排序、归并排序等）通常是更好的选择。