【冒泡排序，简单选择排序，直接插入排序——努力回忆中】

关于冒泡排序

大体思想就是对于一队数字，相邻数字通过比较两两交换，实现从小到大或者从大到小排列。利用两个for循环实现，执行内层for循环可以理解为进行一趟比较，每次比较都可以从无序序列中将一个max或者min值交换到首或者尾（想从大到小排列，就每次比较的时候将较小的[i]交换至[i+1]处，反之同理），外层for循环就是执行数趟，直到全部比较结束（添加flag做标志的话就可以减少一些比较次数，在数列第一次基本有序时就跳出循环~）

import java.util.Arrays;

public class MaoPao {
    public static void main(String[] args) {

        MaoPao maoPao = new MaoPao();
        int[] a= {23,46,1,89,43,22,23,44,3};
        //maopaosort(a);
        int [] maopaosort = maoPao.maopaosort(a);
        //System.out.println(Arrays.toString(maopaosort));//可以直接输出数组
        //或者用循环
       for (int num: maopaosort) {
            System.out.print(num+"\t");
        }



    }
    public int [] maopaosort(int [] b) {

        int temp = 0;
        for (int i = 0; i < b.length - 1; i++) {
            int flag = 0;//标记无序
            for (int j = 0; j < b.length - 1 - i; j++) {
                if (b[j] >= b[j + 1]) {//若左大右小，则data交换
                    temp = b[j];
                    b[j] = b[j + 1];
                    b[j + 1] = temp;
                    flag = 1;//标记有序

                }
            }

            if (flag == 0) {//完成某趟排序后发现已经基本有序，就跳出
                break;
            }

        }
        return b;

    }

}

关于简单选择排序

思想：每一趟都能找出一个当前最小值，比如第一趟找到的最小值放在a[0]，第二趟找到的次小值就放在a[1]，以此类推，这种算法在数列中有相同关键字有序的时候很不稳定，因为交换后会破坏原有关键字的前后顺序，比如1,3,3,2， ,3和2比较，如果有多个3就只能把第一个3换过去，排序后：1，2，3，3 但是原来的 3,3变为3,3，相对位置改变了，现在前后颠倒（虽然看起来一样hh）

public class SelectSort{


    public int[] sort(int arr[]) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            // 认为目前的数就是最小的, 记录最小数的下标
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[minIndex] > arr[j]) { // 修改最小值的下标
                     minIndex = j;
                }
            }
            // 当退出for就找到这次的最小值,就需要交换位置了
            if(i != minIndex) {
                    temp = arr[i];
                    arr[i] = arr[minIndex];
                    arr[minIndex] = temp;
            }
                }
        return arr;
            }

    public static void main(String[] args) {
        SelectSort selectSort = new SelectSort();
        int[] array = {2,5,1,6,4,9,8,5,3,11,2,0};
        int[] sort = selectSort.sort(array);
        for (int num:sort){
            System.out.print(num+"\t");
        }
    }

}

关于直接插入排序

思想：虽然叫直接插入但并不涉及手动插入，而是像整理扑克牌一样，一般我们都习惯将牌升序或者降序排列来方便出牌（也有人会用别的方法，我就是举个栗子）

发牌后发现基本都是乱序，假设我们从左开始理牌，想要让牌从小到大排列。依然是比较思想，先用第二张和第一张比较，然后就是第三张和前两张比较，看起来和选择排序有些像，

用例子说明：

发牌后手中牌：2,6,3,1,13,7,2

第一趟：2，6，3，1，13，7，2     　　无交换

第二趟：2，3，6，1，13，7，2    　　3和6交换

第三趟：1，2，3，6，13，7，2　　　1先和6交换，然后发现1还可以和3交换，交换后，又双叒发现能和2交换，于是就是第三趟排序后就是前面那样子；

第四趟：1，2，3，6，13，7，2　　　　无交换

第五趟：1，2，3，6，7，13，2　　　　7和13交换

第六趟：1，2，2，3，6，7，13　　　　2和13交换，然后2又和7,交换，....交换............最后和3交换，完成排序 

所以，和选择排序还是很有区别的，选择排序是只找当前最小值，然后不断放在序列头部，直接插入虽然也是头部有序，但并不一定是每一趟都能固定好关键字的位置，

简单选择每趟排序都能确定一个关键字的位置，直到最后一趟结合素其位置都不会改变，这点我记得在数据结构中会经常考察。

public class InsertSort {
    private int[] sort(int[] arr) {
        //如果传入的数组为空或者只有一个值,就直接返回
        if (arr == null || arr.length < 2) {
            return arr;
        }//不为空则进循环判断
        // 外层循环控制总数量
        for (int i = 1; i < arr.length; i++) {
            //内层循环依次减少并提出结果
            for (int j = i; j > 0; j--) {
                //如果当前数字小于前一个,则交换,否则不变
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                } else {
                    break;
                }
            }
        }
        return arr;
    }


    public static void main(String[] args) {
        InsertSort insertSort = new InsertSort();
        int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
        int[] sort = insertSort.sort(array);
        for (int num : sort) {
            System.out.print(num + "\t");
        }
    }
}