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

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

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

 

 

一.冒泡排序概述

1>.冒泡排序总结

　　冒泡法
　　　　属于交换排序
　　　　两两比较大小，交换位置。如同水泡咕嘟咕嘟往上冒
　　　　结果分为升序和降序排列

　　升序
　　　　n个数从左至右，编号从0开始到n-1，索引0和1的值比较，如果索引0大，则交换两者位置，如果索引1大，则不交换。继续比较索引1和2的值，将大值放在右侧。直至n-2和n-1比较完，第一轮比较完成。第二轮从索引0比较到n-2，因为最右侧n-1位置上已经是最大值了。依次类推，每一轮都会减少最右侧的不参与比较，直至剩下最后2个数比较。

　　降序
　　　　和升序相反

　　冒泡法时间复杂度相关总结:
　　　　冒泡法需要数据一轮轮比较
　　　　可以设定一个标记判断此轮是否发生数据交换，如果没有发生交换，可以结束排序，如果发生交换，继续下一轮排序
　　　　最差的情况是，初始顺序与目标顺序完全相反，遍历次数1,...,n-1之和n(n-1)/2
　　　　最好的情况是，初始顺序和目标顺序完全相同，遍历次数n-1
　　　　时间复杂度O(n2)

2>.冒泡法原理

初始值：[1 9 8 5 6 7 4 3 2]

第一趟：[1 8 9 5 6 7 4 3 2] [1 8 5 9 6 7 4 3 2] [1 8 5 6 9 7 4 3 2] [1 8 5 6 7 9 4 3 2] [1 8 5 6 7 4 9 3 2] [1 8 5 6 7 4 3 9 2] [1 8 5 6 7 4 3 2 9]

第二趟：[1 8 5 6 7 4 3 2 9] [1 5 8 6 7 4 3 2 9] [1 5 6 8 7 4 3 2 9] [1 5 6 7 8 4 3 2 9] [1 5 6 7 4 8 3 2 9] [1 5 6 7 4 3 8 2 9] [1 5 6 7 4 3 2 8 9]

第三趟：[1 5 6 7 4 3 2 8 9] [1 5 6 4 7 3 2 8 9] [1 5 6 4 3 7 2 8 9] [1 5 6 4 3 2 7 8 9]

第四趟：[1 5 6 4 3 2 7 8 9] [1 5 4 6 3 2 7 8 9] [1 5 4 3 6 2 7 8 9] [1 5 4 3 2 6 7 8 9]

第五趟：[1 5 4 3 2 6 7 8 9] [1 4 5 3 2 6 7 8 9] [1 4 3 5 2 6 7 8 9] [1 4 3 2 5 6 7 8 9]

第六趟：[1 4 3 2 5 6 7 8 9] [1 3 4 2 5 6 7 8 9] [1 3 2 4 5 6 7 8 9]

第七趟：[1 3 2 4 5 6 7 8 9] [1 2 3 4 5 6 7 8 9]

第八趟：[1 2 3 4 5 6 7 8 9]

二.使用编程语言实现选择排序

1>.Python实现版本

　　博主推荐阅读:
　　　　https://www.cnblogs.com/yinzhengjie/p/10958304.html

2>.Golang实现版本

package main

import (
    "fmt"
)

func main() {

    arr := [10]int{1, 9, 8, 5, 6, 7, 0, 4, 3, 2}
    fmt.Printf("arr数组未经过排序之前,元素顺序为:%d
", arr)

    //外层循环控制行，表示执行次数
    for i := 0; i < len(arr)-1; i++ {
        //内层循环控制列，表示比较次数
        for j := 0; j < len(arr)-1-i; j++ {
            //比较两个相邻元素
            if arr[j] > arr[j+1] {
                //交换数据
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }

    fmt.Printf("arr数组经过排序之后,元素顺序为:%d
", arr)
}

package main

import (
    "fmt"
)

func BubbleSort(s1 []int) {
    for i := 0; i < len(s1)-1; i++ {
        for j := 0; j < len(s1)-1-i; j++ {
            if s1[j] > s1[j+1] {
                s1[j], s1[j+1] = s1[j+1], s1[j]
            }
        }
    }
}

func main() {

    arr := []int{1, 9, 8, 5, 6, 7, 0, 4, 3, 2}
    fmt.Printf("arr数组未经过排序之前,元素顺序为:%d
", arr)

    BubbleSort(arr)

    fmt.Printf("arr数组未经过排序之前,元素顺序为:%d
", arr)

}

3>.Java实现版本

/**
 *    冒泡排序
 *     @author 尹正杰
 */
public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] arr = {1,20,3,80,5,200,175,10};
        System.out.println("排序前:"); 
        printArray(arr);
        selectSort(arr);
        System.out.println("排序后:");
        printArray(arr);
    }
    
    public static void selectSort(int[] arr) {
        //外层循环控制循环次数
        for (int i = 0; i < arr.length - 1 ; i++) {
            //“-i”的目的是为了让每次参与比较的元素递减,“-1”是为了避免索引越界异常
            for (int j = i; j < arr.length - i - 1; j++) {
                //当前一个元素比另一个元素大的时候,进行位置互换
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
    
    public static void printArray(int[] arr) {
        System.out.print("	");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "	");
        }
        System.out.println();
    }
}