java实现冒泡排序与选择排序

学习笔记之冒泡排序与选择排序～

冒泡排序：

基本思想：

通过对待排序序列从前往后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前往后移，像水底下的气泡一样逐渐往上冒

因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换，从而减少不必要的比较

如果一趟比较下来没有进行过交换，就说明序列有序，可以提前结束。这个就是优化。

package com.lmh.sort;

import java.lang.reflect.Array;
import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3, 9, -1, 10, -2};

        bubbleSort(arr);


        //第一趟排序，将最大的一个数排到最后
        int temp = 0;//临时变量
        for (int j = 0; j < arr.length - 1; j++) {
            //如果前面一个数比后面数大则交换
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第一趟排序");
        System.out.println(Arrays.toString(arr));
        //第二趟排序，排倒数第二个
        for (int j = 0; j < arr.length - 1 - 1; j++) {
            //如果前面一个数比后面数大则交换
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第二趟排序");
        System.out.println(Arrays.toString(arr));


        //第三趟排序，排倒数第三个
        for (int j = 0; j < arr.length - 1 - 1 - 1; j++) {
            //如果前面一个数比后面数大则交换
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第三趟排序");
        System.out.println(Arrays.toString(arr));

        //第四趟排序，排倒数第四个
        for (int j = 0; j < arr.length - 1 - 1 - 1 - 1; j++) {
            //如果前面一个数比后面数大则交换
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第四趟排序");
        System.out.println(Arrays.toString(arr));

        //第五趟排序，排倒数第五个
        for (int j = 0; j < arr.length - 1 - 1 - 1 - 1 - 1; j++) {
            //如果前面一个数比后面数大则交换
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第五趟排序，没必要进行");
        System.out.println(Arrays.toString(arr));


        //双层循环，冒泡排序O(n^2)
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //如果前面一个数比后面数大则交换
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("冒泡排序");
            System.out.println(Arrays.toString(arr));
        }


        //优化，加一个flag判断
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //如果前面一个数比后面数大则交换
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("冒泡排序");
            System.out.println(Arrays.toString(arr));

            if (!flag){//没有发生交换
                break;
            }else {
                flag = false;//重置flag，进行下次判断
            }
        }
    }
    //封装成一个方法
    public static void bubbleSort(int[] arr){
        //优化，加一个flag判断
        boolean flag = false;
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //如果前面一个数比后面数大则交换
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("冒泡排序");
            System.out.println(Arrays.toString(arr));

            if (!flag){//没有发生交换
                break;
            }else {
                flag = false;//重置flag，进行下次判断
            }
        }
    }

}

选择排序思想：

第一次从arr[0]_{arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]}arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]~arr[n-1]中选取最小值，与arr[2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列

package com.lmh.sort;

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101, 34, 119, 1};
        System.out.println("排序前");
        System.out.println(Arrays.toString(arr));
        System.out.println("排序后");
        selectSort(arr);
    }

    public static void selectSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {


            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {
                    //说明min不是最小
                    min = arr[j];//重置min
                    minIndex = j;//重置min的下标
                }
            }
            //将最小值，放在arr[0]，交换
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = min;

            }

            System.out.println("第"+(i+1)+"轮选择排序后");
            System.out.println(Arrays.toString(arr));


        }
    }
}