JAVA算法的简单了解-简单排序算法和冒泡算法

public class Paixu {
    public static void main(String[] args) {
        DuoTai duoTai1 = new DuoTai();
        int [] arr = {2,34,13,23,41,10};
        int [] arr1={14,12,2,4,18,24,1};
        duoTai1.SelectionSort(arr);
        duoTai1.maopao(arr1);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));
    }
//选择排序算法
//int[] arr = {2, 34, 13, 23, 41, 10};array.length为6
    public void SelectionSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = i + 1; j < array.length; j++) {
                int temp;
                if (array[i] > array[j]) { //0和1比较，0和2比较，0和3比较，，，，，下来是1和2比较，1和3比较，，，，
                    temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    }
//i = 0, j = 1, 2≯34，然后j + 1，j = 2 2≯34，然后j + 2.。。。。。。。最后array[i = 0] 就为2，这里进行了5次比较
// i=1，j=2,34>13,那么 执行if中语句，arr[i=1]=13。然后j+1，j=3，13≯23，。。。。最后j+3，j=5，13>10，那么进行if语句
// 最后arrary[i=1]就为10，这里进行了4次比较
//依次类推，进行3次比较，2次比较，1次比较，最后排序好数组顺序。一个进行了5+4+3+2+1=15次比较。
// 如果是int[]arr=new int[n]的数组要排序顺序，那就需要（n-1）+（n-2）+（n-3）+（n-4）。。。。。+1=（n²+1）/2次比较，
//因此简单排序的时间复杂度为O（n²）。
//第一次排序之后：2, 34, 13, 23, 41, 10
//第二次排序之后：2, 10, 34, 23, 41, 13
//第三次排序之后  2, 10, 13, 34, 41, 23
//第四次排序之后：2, 10, 13, 23, 41, 34
//第五次排序之后：2, 10, 13, 23, 34, 41




//冒泡算法
//int[] arr1 = {14, 12, 2, 4, 18, 24, 1}; array.length为7
    public void maopao(int[] array) {
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {   //0和1比较，1和2比较，2和3比较，3和4比较，4和5比较，，，下来是
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}
//i=0,j=0,14>12，那么array[j=0]为12，然后j+1，j=1，14>2，那么array[j=1]为2,依次类推，这是i=0完成的排序12 2 4 14 18 1 24，进行了6次比较
//依次类推  第二次i=1时候 排完的顺序为 2 4 12 14 1 18 24 进行了5次比较（注意这个判定条件j < array.length - i - 1）
//第三次 i =2时候   2 4 12 1 14 18 24  进行了4次
//第四次 i =3时候， 2 4 1 12 14 18 24  进行了3次
//第五次：2 1 4 12 14 18 24  进行了2次
//第六次：1 2 4 12 14 18 24  进行了1次
//这里注意到在第三次除了数字1还没有排序好之外，其他数字都排序完成，这是因为我写的这个数组将最小的数字放在了最后一个，因此这样的数组（最小的在最后一个）是冒泡排序最差的情况。
// 如果是int[]arr=new int[n]的数组要排序顺序，那也需要（n-1）+（n-2）+（n-3）+（n-4）。。。。。+1=（n²+1）/2次比较
//因此在最差情况下：冒泡算法排序的时间复杂度也为O（n²）
//当然如果理想情况下，一次就可以排序完成的，这种情况下需要比较n-1次，这个时候的时间复杂度为O（n）。