冒泡排序与插入排序

冒泡排序

它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

​ 时间复杂度：两层循环 ，O(n^2)

​ Java实现

private static void bubbleSort(int[] arr) {
    //最外层循环定义需要比较的次数
    for(int i = 0; i < arr.length - 1; i ++){
        // arr.length - i - 1 的意思是，数组后面的元素已经是冒泡过去的，不需要在比较
        for(int j = 0; j < arr.length - i - 1 ; j ++){
            //前一位跟后一位比较，前一位大交换位置，正序排序。倒过来是倒序排序
            if(arr[j] > arr[j + 1]){
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                printArray(arr);
            }
        }
    }
}

private static void printArray(int[] arr){
    Arrays.stream(arr).forEach(i->{
        System.out.print(i + " ");
    });
    System.out.println();
}

直接插入排序

直接插入排序（Straight Insertion Sort）是一种最简单的排序方法，其基本操作是将一条记录插入到已排好的有序表中，从而得到一个新的、记录数量增1的有序表。

​ For循环

public static void insertSort(int[] arr){
    //数组第一位（i=0）默认自己有序
    for(int i = 1; i < arr.length;i ++){
       //如果第i个元素 小于 i-1元素，说明从i开始补一致。i-1个元素是有序的。（降序排序把这里的判断和下面的改为大于号>）
        if(arr[i] < arr[i-1]){
            //第i位元素依次向前比较
            for(int j = i; j > 0;j --){
                //当j-1的位置小于等于j位置，结束比较，说明数组开始有序
                if(arr[j-1] <= arr[j]){
                  break;
                }
                //交换位置
                int temp = arr[j-1];
                arr[j-1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

​ While循环

public static void insertSort1(int[] array){
    //第0位独自作为有序数列，从第1位开始向后遍历
    for(int i = 1;i < array.length; i++)   {
        //0~i-1位为有序，若第i位小于i-1位，继续寻位并插入，否则认为0~i位也是有序的，忽略此次循环，相当于continue
        if(array[i]<array[i-1])  {
            //保存第i位的值
            int temp = array[i];
            int j = i - 1;
            //从第i-1位向前遍历并移位，直至找到小于第i位值停止
            while(j>=0 && temp<array[j]){
                array[j+1]=array[j];
                j--;
            }
            //插入第i位的值
            array[j+1] = temp;
        }
    }
}

折半插入排序

折半插入排序（binary insertion sort）是对插入排序算法的一种改进，由于排序算法过程中，就是不断的依次将元素插入前面已排好序的序列中。由于前半部分为已排好序的数列，这样我们不用按顺序依次寻找插入点，可以采用折半查找的方法来加快寻找插入点的速度。

​ 二分查找

/**
 * 二分查找
 */
public static int binarySearch(int[] arr,int var1){
    //开始下标
    int start = 0;
    //结束下标
    int end = arr.length - 1;
    while (start <= end){
        //算出中间的下标
        int mid = (end - start)/2 + start;
        //相等直接返回
        if(arr[mid] == var1){
            return mid;
        }else if(var1 < arr[mid]){
            //如果小于中间值，将结束下标变成 mid - 1,继续比较
            end = mid - 1;
        }else {
            //如果大于中间值，将开始下标变成 mid + 1,继续比较
            start = mid + 1;
        }
    }
    return -1;
}

​ 折半插入排序

public static void binsertSort(int[] arr){
    //数组第一位（i=0）默认自己有序
    for(int i = 1; i < arr.length;i ++){
        //如果第i个元素 小于 i-1元素，说明从i开始补一致。i-1个元素是有序的。（降序排序把这里的判断和下面的改为大于号>）
        if(arr[i] < arr[i-1]){
            int start = 0;
            int end = i;
            //折半查找
            while (start <= end){
                int mid = (end - start)/2 + start;
                //中间元素小于当前最外层替换位置的元素，则在前一半寻找
                if(arr[i] < arr[mid]){
                    end = mid - 1;
                }else {
                    //后一半寻找
                    start = mid + 1;
                }
            }
            //找到应该插入的位置之后，做位置插入操作。临时保存位置i的值，将前面元素后移一位
            int temp = arr[i];
            for(int j = i; j >= start+1;j --){
                arr[j] = arr[j - 1];
            }
            arr[start] = temp;
        }
    }
}