数据结构复习：排序——冒泡排序

为什么叫冒泡排序

冒泡排序是最基础的交换排序方式。起名冒泡的原因是每一个元素都可以根据自身大小一点一点向数组的一侧移动。这个过程像泡泡浮出的过程，所以叫冒泡排序。

如何实现

冒泡排序的每一趟都只会将一个数归位（比较相邻两数的大小来决定是否交换，在一趟循环结束后，经过交换后一定是最大的数在末尾），因此要实现n个数的冒泡排序，我们要将n-1个数归位，剩下最后的数即自己的位置。也就是说我们要实现冒泡排序需要进行n-1躺操作。每一次操作都需要从第一位开始冒泡直到已经归位的数。

这里使用了一张动图来直观的表现冒泡排序的过程（此图参考@烟雨倾城ゝ）

排序特点

• 时间上：冒泡排序的速度并不理想，时间复杂度较高
• 空间上：只使用了一个辅存单元，不占用空间

时间复杂度

• 最优时间复杂度：O(n)
• 最优时间复杂度：O(n^2)
• 稳定性：稳定

代码实现

java

import java.util.LinkedList;

 class bubble_sort {
    int[] datas;
    public bubble_sort(int []datas){
        this.datas=datas;
    }
    public void sort() {
        int temp;
        for (int i = 0; i < this.datas.length - 1; i++) {
            for (int j = i + 1; j < this.datas.length; j++) {
                if (this.datas[j] < this.datas[i]) {//交换数据
                    temp = this.datas[j];
                    this.datas[j] = this.datas[i];
                    this.datas[i] = temp;
                }
            }
        }
    }
    public void print(){
        LinkedList list =new LinkedList();
        for(int i=0;i< datas.length;i++){
            list.add(datas[i]);
        }
        System.out.println(list);
    }
     public static class SortTest{
         public static void main(String[] args) {
            test_bubblesort();
         }
     public static void test_bubblesort(){
             int[] arrays={5, 9, 1, 9, 5, 3, 7, 6, 1};
             bubble_sort bubbleSort=new bubble_sort(arrays);
             bubbleSort.sort();
             bubbleSort.print();
        }
    }
}

 c

# include <stdio.h>
# include <stdlib.h>
int main() {
    int a[] = {5, 9, 1, 9, 5, 3, 7, 6, 1};
    int n;  //存放数组a中元素的个数
    int i;  //比较的轮数
    int j;  //每轮比较的次数
    int buf;  //交换数据时用于存放中间数据
    n = sizeof(a) / sizeof(a[0]);  /*a[0]是int型, 占4字节, 所以总的字节数除以4等于元素的个数*/
    for (i = 0; i < n - 1; ++i)  //比较n-1轮
    {
        for (j = 0; j < n - 1 - i; ++j)  //每轮比较n-1-i次,
        {
            if (a[j] < a[j + 1]) {
                buf = a[j];
                a[j] = a[j + 1];
                a[j + 1] = buf;
            }
        }
    }
    for (i = 0; i < n; ++i) {
        printf("%d\x20", a[i]);
    }
    printf("\n");
    system("pause");
}

 python

# 随机生成
import numpy as np

def bubble_sort(nums):
    for i in range(0,len(nums)-1):
        for j in range(0,len(nums)-1-i):
           if nums[j] > nums[j+1]:
                nums[j], nums[j + 1] = nums[j + 1], nums[j]
    return nums
if __name__ == '__main__':
    # 打乱顺序并随机生成
    nums=np.random.permutation(20)
    print(bubble_sort(nums))

通过上面的代码我们可以直观的观察到冒泡排序的核心就是双重嵌套循环