【java排序算法】冒泡和选择排序及优化

1、冒泡排序 ：
描述：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
代码实现：

low版本:
public class BubbleSort {
    public static void  sort(int[] arr){
        for (int i = 1; i < arr.length; i++) {  //第一层for循环,用来控制冒泡的次数
            for (int j = 0; j < arr.length-1; j++) { //第二层for循环,用来控制冒泡一层层到最后
                //如果前一个数比后一个数大,两者调换 ,意味着泡泡向上走了一层
                if (arr[j] > arr[j+1] ){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

/*
冒泡排序优化：
优化的思路：
当没有任何数据交换时，就说明此序列已经有序，不要再继续后面的循环判断工作了。
为了实现这个想法，需要改进上面的代码，增加一个标志位flag即可
*/
public class BubbleSortPlus {
    public static void sortPlus(int[] a) {
  /*      if (a == null && a.length <= 0) {
            return;
        }
        boolean flag = true;//初始化一个布尔值标志位
        for (int i = 0; i < a.length && flag; i++) {
            flag = false;
            for (int j = a.length - 2; j >= i; j--) {//从后往前循环
                if (a[j] > a[j + 1]) {
                    int temp = a[j];//设置中间变量temp进行交换
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    flag = true;//有交换则标志位为true
                }
            }
        }*/

        if (a != null && a.length > 1) {
            for (int i = 0; i < a.length - 1; i++) {
                // 初始化一个布尔值
                boolean flag = true;
                for (int j = 0; j < a.length - i - 1; j++) {
                    if (a[j] > a[j + 1]) {
                        // 调换
                        int temp;
                        temp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = temp;
                        // 改变flag
                        flag = false;
                    }
                }
                if (flag) {
                    break;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = {2, 1, 3, 4, 5, 6, 7, 8};
        sortPlus(arr);
        System.out.println(Arrays.toString(arr));
    }
}

2、选择排序 ：
描述：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
也就是说，先拿第一个跟第二个、第三个、第四个…比，比完之后第一个最小；然后拿第二个跟第三个、第四个、第五个…比，比完之后第二个最小；以此类推。
代码实现：

/*
选择排序：第一轮用第一个元素与后面的所有元素比较找到最小的那一个与第一个元素交换位置，
如果没找到则不交换。 第二轮用第二个元素进行类似第一轮的操作，如此类推。
*/
public class ChooseSort {
    public static void sort(int[] arr, int len) {
       /* for (int i = 0; i < arr.length - 1; i++) {
            int min = i;//遍历的区间最小的值
            for (int j = i + 1; j < arr.length - 1; j++) {
                if (arr[j] < arr[min]) {
                    min = j;//找到当前遍历区间最小值的索引
                }
            }
            if (min != 0) {//进行调换
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
    }*/
        //优化：在找最大值得同时，也找最小值，这样可以减少排序的趟数。
        for (int i = 0; i < len / 2; i++) {//排序的趟数
            int max = i;//记录最大值得下标
            int min = i;
            for (int j = 1 + i; j < len - i - 1; j++) {//比较元素的次数，左边+，右边-
                if (arr[max] < arr[j]) {
                    max = j;
                }
                if (arr[min] > arr[j]) {
                    min = j;
                }
            }
            if (arr[max] != arr[len - i - 1]) {//如果最大的数，没有在对应的位置才进行交换
                int tmp = arr[len - i - 1];
                arr[len - i - 1] = arr[max];
                arr[max] = tmp;
            }
            if (arr[min] != arr[i]) {//如果最小的数，没有在其对应的位置才进行交换
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }
        }
    }


    public static void main(String[] args) {
        int[] arr = {1, 5, 7, 3, 8, 2, 9, 7};
        sort(arr, arr.length);
        System.out.println(Arrays.toString(arr));
    }
}