java数组排序

冒泡排序

冒泡排序是每个后端开发人员必须掌握的排序算法，也是最容易理解的排序算法。主要使用嵌套循环，假设数组长度为10，以从小到大排序为例，内层循环中，将相邻的元素进行比较，比较后将较大的数向后移(例如array[0]大于array[1],则交换二者的位置)，每执行完一次内层循环，则将最大的元素放到数组的末尾。则执行9(数组长度-1)次内层循环，则确定了9个数的位置，自然最后一个数的位置也确定了。
例如有数组{5,239,9,1,534,23,99,86,53,6}，内层循环依次比较下标为0和下标为1，1和2,2和3……，若下标小的对应的元素值大，则交换位置，因此，第一次内层循环执行完成后534就移动到了最末尾，第二次内层循环就不用考虑最后一个元素了，即将239放到倒数第二个位置，9次执行完毕即完成排序。
具体看以下代码

package com.harbor.sort;

import java.util.Arrays;

/**
 * 冒泡排序
 * @author harborGao
 * @create 2020/3/7
 */
public class BubbleSort {
   
    public static void main(String[] args) {
   
        int[] arr = {
   5,239,9,1,534,23,99,86,53,6};
        bubbleSort(arr); //数组进行冒泡排序
        System.out.println(Arrays.toString(arr));  //输出排序后的数组
    }

    /**
     * 冒泡排序
     * @param arr 待排序的数组
     */
    public static void bubbleSort(int[] arr){
   
        int len = arr.length; // 获取数组元素的个数
        boolean flag = true; //内层循环中if语句没有执行则说明排序已完成
        //循环执行len-1次，每次循环确定一个元素的位置，i即为以确定位置元素的个数
        for(int i = 0; i < len-1; i++){
   
            for(int j = 0; j < len-i-1; j++){
    //内层循环将最大的元素放到最末尾的位置
                if(arr[j] > arr[j+1]){
   
                    swap(arr,j,j+1);
                    flag = false; //说明排序有可能还没有完成
                }
            }
            if(flag)
                return;
        }
    }

    /**
     * 交换两个变量的值
     * @param arr
     * @param i
     * @param j
     */
    public static void swap(int[] arr,int i,int j){
   
        //写法一
//        int temp = arr[i];
//        arr[i] = arr[j];
//        arr[j] = temp;
        //写法二
//        arr[i] = arr[i]+arr[j];
//        arr[j] = arr[i]-arr[j];
//        arr[i] = arr[i]-arr[j];
        //写法三
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }
}

注意:此代码中有一个布尔类型变量flag，是对冒泡排序的一种优化，执行内层循环之前初始化其为true，若内层循环执行完成flag依然为true(if语句块没有执行),则说明排序已经完成。即可跳出外层循环！

插入排序

插入排序与冒泡排序可以说有异曲同工之妙，同样也是使用嵌套循环，只是内部逻辑发生了一点变化。假设要长度为10的数组arr进行插入排序，我们可以理解为次数组中只有一个元素arr[0]，我们需要将其余的9个元素插入其中，则我们可以遍历下标为1到9的9个元素依次进行插入。所以，外层循环即为对数组的遍历，内层循环则做插入操作
1.arr[1]的插入我们需要比较他与arr[0]到底谁大，若arr[1]较大，我们则直接插入即可，若arr[1]较小，我们则需要交换其与arr[0]的位置。
2然后，我们需要插入arr[2],则内层循环需要先和arr[1]进行比较，若较大，则不需要移动。若较小，我们需要与arr[1]交换位置，并且再继续与arr[0]比较，若小于arr[0]，则还需要与arr[0]交换位置。
3.接下来的7个元素执行同样的操作即可
例如，有数组arr = {56,9,53,1,56,9,55,76,531,222};我们可以看做数组中只有一个元素56，则将其他9个元素依次插入
1.插入9,我们与56比较，发现9<56，我们则需要交换位置
2.插入53，此时数组为{9,56,……},我们与56比较大小，发现53<56,则交换二者位置，我们再与9比较，发现53>=9，则不需要交换位置
3.剩下7个元素也是做同样的操作

具体实现代码如下：

package com.harbor.sort;

import java.util.Arrays;

/**
 * 插入排序
 * @author harborGao
 * @create 2020/3/7
 */
public class InsertSort {
   
    public static void main(String[] args) {
   
        int[] arr = {
   56,9,53,1,56,9,55,76,531,222};
        insertSort(arr); //数组进行插入排序
        System.out.println(Arrays.toString(arr)); //输出排序后的数组
    }

    /**
     * 插入排序
     * @param arr 传入的数组
     */
    public static void insertSort(int[] arr){
   
        int len = arr.length; //获取数组的长度
        //从第二个元素开始与前面的数组比较，若比前面的小，则交换位置
        for(int i = 1; i < len; i++){
   
            for(int j = i - 1; j >= 0; j--){
   
                //下标为i的元素依次与小于下标i的元素比较，若小于，则交换
                if(arr[j+1