数据结构之冒泡、选择排序

冒泡排序和选择排序都属于内部排序，这两种排序方式的平均时间复杂度和最坏时间复杂度都是，并且他们都适用于数据比较少的情况下使用，不同的是冒泡排序比选择排序更稳定。下面分别聊聊这两种排序方式吧。

一、冒泡排序

冒泡排序是对待排序序列下标有小到大开始遍历比较，若这两个元素逆序，则交换，不逆序则继续比较一下一个，比较数组长度-1趟即可。若是某一趟没有交换，则证明这个数组序列有序，退出即可。代码如下：

/**
 * 冒泡排序：每一趟都只是比较相邻两个数的大小，再按照给定规则交换
 * 优化：要是某一趟中没有进行数据交换，证明这个数组是有序的，不用在进行排序，
 * 设置flag标志位判断是否进行了交换
 */
public class BubbleSort {
    public static void main(String[] args) {
//        int[] arr = {3,9,-1,10,-2};
        int[] arr = {1,2,3,4,5,6};
        BubbleSort bubbleSort = new BubbleSort();
        bubbleSort.sort(arr);
        bubbleSort.print(arr);
    }
    private void sort(int[] arr){
        int temp = 0;
        boolean flag = false;
        //外层循环代表进行几趟排序，进行数组长度-1次趟排序即可
        for (int i = 0; i < arr.length-1; i++) {
            //内层循环代表每趟比较多少次，由于每趟排序都能确定一个最大数，
            // 所以比较数组长度-1-i次即可
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j] > arr[j+1]){
                    flag = true;
                    System.out.println("交换啦....");
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;

                }
            }
            if (!flag){
                //没有进行交换，数组有序
                break;
            }else {
                //某一趟交换了，需要将标志位初始化，便于判断下一趟是否交换
                flag = false;
            }
        }
    }
    private void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

二、选择排序

选择排序则是按照某一规则选出一个元素（这里是选出最小元素）,再按照某一规则交换（在数组中找到更小的元素则交换数组这两个元素的位置），最终得到一个有序的数组。代码如下：

/**
 * 选择排序，总共进行数组长度-1趟，每一趟中假定第一个元素最小，并记录下标，挨个何数组中的
 * 其他元素比较，要是大于其他元素，替换最小值和下标。最后交换最小值和第一个元素。
 * 从下到大排序，由于每趟均能确定一个最小数，故每趟的第一个元素不一样
 */
public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101,34,119,1,-1,90,123};
        SelectSort selectSort = new SelectSort();
        selectSort.sort(arr);
    }
    private void sort(int[] arr){
        //外层循环，控制趟数
        for (int i = 0; i < arr.length-1; i++) {
            //记录最小值和下标,第一趟是arr[0]，第二趟是arr[1]。。。
            int minVal = arr[i];
            int index = i;
            for (int j = i+1; j < arr.length; j++) {
                if (minVal > arr[j]){
                    minVal = arr[j];
                    index = j;
                }
            }
            //出内循环，找到最小值,交换
            if (i != index){
                arr[index] = arr[i];
                arr[i] = minVal;
            }
            System.out.printf("第%d趟排序后结果：",i+1);
            print(arr);
            System.out.println();
        }
    }
    private void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

每趟冒泡排序后，确定的元素在数组的后面存放，而每趟插入排序后，确定的元素在数组的前面存放。