排序--01---概述---冒泡排序

Posted 2021-08-11 高高for 循环

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了排序--01---概述---冒泡排序相关的知识，希望对你有一定的参考价值。

排序概述

在这里插入图片描述

十大内部排序算法

在这里插入图片描述

比较和非比较的区别:

比较排序

常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。
在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。
比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

非比较排序:

计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。
非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。
非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

算法的选择:

在这里插入图片描述

冒泡排序（Bubble Sort）:

排序原理：

比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
.

代码实现1

public class BubbleSort {
    public static void bubbleSort(int[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;

        for (int i = 0; i < arrayLength - 1; i++) {
            for (int j = 0; j < arrayLength - 1 - i; j++) {
                if (data[j] > data[j + 1]) {
                    int temp = data[j + 1];
                    data[j + 1] = data[j];
                    data[j] = temp;
                }
            }
            System.out.println(java.util.Arrays.toString(data));
        }
    }


    public static void main(String[] args) {
        int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
        
        System.out.println("排序之前：\\n" + java.util.Arrays.toString(data));
        bubbleSort(data);
        System.out.println("排序之后：\\n" + java.util.Arrays.toString(data));
    }
}

在这里插入图片描述

代码优化 2

通过标记 flag来判断是否进行了交换，如果没有则直接退出循环，从而达到了对排序的进一步优化。

public class BubbleSort {
    //优化1
    public static void bubbleSort1(int[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;
        
        for (int i = 0; i < arrayLength - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < arrayLength - 1 - i; j++) {
                if (data[j] > data[j + 1]) {
                    int temp = data[j + 1];
                    data[j + 1] = data[j];
                    data[j] = temp;
                    flag = true;
                }
            }
            
            System.out.println(java.util.Arrays.toString(data));        
            if (!flag)
                break;
        }    
    }

    public static void main(String[] args) {
        int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };

        System.out.println("排序之前：\\n" + java.util.Arrays.toString(data));
        bubbleSort1(data);
        System.out.println("排序之后：\\n" + java.util.Arrays.toString(data));
    }
}

在这里插入图片描述

对象冒泡排序 3

DataWrap

public class DataWrap implements Comparable<DataWrap>{
    int data;
    String flag;
    public DataWrap(int data,String flag){
        this.data = data;
        this.flag = flag;
    }
    public String toString(){
        return data + flag;
    }
    //根据data实例变量来决定两个dataWrap的大小
    @Override
    public int compareTo(DataWrap dw) {
        return this.data > dw.data? 1 : (this.data == dw.data? 0 : -1);
    }

}

BubbleSort02

public class BubbleSort02 {
    public static void bubbleSort(DataWrap[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;

        for (int i = 0; i < arrayLength - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < arrayLength - 1 - i; j++) {
                if (data[j].compareTo(data[j + 1]) > 0) {
                    DataWrap temp = data[j + 1];
                    data[j + 1] = data[j];
                    data[j] = temp;
                    flag = true;
                }
            }
            System.out.println(java.util.Arrays.toString(data));
            if (!flag)
                break;
        }
    }

    public static void main(String[] args) {
        DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),
                new DataWrap(21, "*"), new DataWrap(23, ""),
                new DataWrap(-30, ""), new DataWrap(-49, ""),
                new DataWrap(21, ""), new DataWrap(30, "*"),
                new DataWrap(30, "")};
        System.out.println("排序之前：\\n" + java.util.Arrays.toString(data));
        bubbleSort(data);
        System.out.println("排序之后：\\n" + java.util.Arrays.toString(data));
    }
}