二分法，冒泡，选择，插入排序

二分法查找

算法描述：有已排序的数组，定义左边界和右边界，确定搜索范围，循环执行二分法查找。

步骤：

1. 获取中间索引M = (L + R)/2
2. 将中间索引与需要搜索的值进行比较
   1. 若搜索值等于中间索引，返回结果
   2. 若搜索值大于中间索引，左索引为M + 1，重新查找
   3. 若搜索值小于中间索引，右索引为M - 1，重新查找
3. 当左索引大于右索引时，没有找到搜索的值，循环结束

算法实现：

public class BinarySearch {
    public static int binarySearch(int[] array, int t){
        int res = 0;
        int left = 0;
        int right = array.length - 1;
        int count = 0;
        while (array[left] < array[right]){
            ++count;
            //int m = (L + R)/2;
            int m = left + (right - left)/2;
            //若中间值等于搜索值，直接返回
            if (array[m] == t){
                res = array[m];
                break;
            }
            //若中间值小于搜索值
            if(array[m] < t){
                //右索引变为中间值并向左移动一位
                left = m + 1;
            }
            //若中间值大于搜索值
            if (array[m] > t){
                right = m - 1;
            }
        }
        //若左索引大于右索引
        if(array[left] > array[right]){
            throw new RuntimeException("未找到这个数字");
        } else {
            System.out.print("循环了" + count + "次");
            return res;
        }
    }

    public static void main(String[] args) {
        int[] a = {1,5,8,11,26,32,34,46,47,58};
        int t = 15;
        int result = binarySearch(a, t);
        System.out.println("结果是"  + result);
    }
}

冒泡排序

算法描述：在一组无序的数组中，将相邻的两个元素进行比较，若是前面的元素大于后面的元素进行比较，若前面的元素大于后面的元素，则将这两个元素的位置进行交换，一直向后推移，直到最大的元素在数组末尾，一直循环知道数组呈顺序排列。

步骤：

1. 将第一个元素与第二个元素进行比较
   1. 若第一个元素大于第二个元素，则进行交换，在将第二个元素与第三个元素进行比较，以此循环
   2. 若第一个元素小于第二个元素，不交换，再将第二个元素与第三个元素进行比较，以此循环
2. 执行上述步骤，知道最大的数到达数组末尾
3. 继续进行比较，指向第一步，知道第二大的数到达数组的倒数第二的位置
4. 以此循环，直到数组全部排序完成

算法实现：

import java.util.ArrayList;
import java.util.Arrays;

public class BubbleSort {
    public static void bubbleSearch(int[] array){
        //外循环，控制整个数组的排序
        for (int i = 0; i < array.length - 1; i++){
            boolean falg = false;
            //内循环，将里面的元素放到它们应该呆的地方
            for (int j = 0; j < array.length - 1 - i; j++){
                if (array[j] > array[j + 1]){
                    swap(array, j, j + 1);
                    falg =true;
                }
            }
            //当某一轮冒泡没有发生交换，那么flag为false，此时数组已经排好序了，可以结束了
            if (!falg){
                break;
            }
        }
        System.out.println(Arrays.toString(array));
    }
    //将数组中的两个元素进行交换
    public static void swap(int[] array, int a,int b){
        int temp = 0;
        temp = array[a];
        array[a] = array[b];
        array[b]  = temp;
    }

    public static void main(String[] args) {
        int[] a = {5,78,9,65,12,33,51,46,20,31};
        bubbleSearch(a);
    }
}

选择排序

算法描述：在无序的数组中，找到最小的元素将其放在第一位，然后在剩余的元素找找到最小的元素放在第二位，以此类推，直到排序完成

步骤：

1. 找到数组中的最小元素，与第一位的元素交换，若最小元素就在第一位或与第一位元素相等则跳过
2. 在剩下的元素中找到最小元素，与第二位元素交换，若最小元素本身就在第二位或者与第二位元素相等则跳过
3. 以此类推直到排序结束

算法实现：

import java.util.Arrays;

public class SelectSort {
    public static void selectSearch(int[] array){
        for (int i = 0; i < array.length - 1; i++){
            //目前最小元素索引为i
            int min = i;
            for (int j = i + 1; j < array.length; j++){
                //若当前元素小于索引为min的元素
                if(array[j] < array[min]){
                    min = j;
                }
            }
            //找到剩下元素中的最小元素后与索引为i的元素进行比较
            if (array[i] != array[min]){
                swap(array, i, min);
            }
        }
        System.out.println(Arrays.toString(array));
    }
    public static void swap(int[] array, int a, int b){
        int temp = 0;
        temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }

    public static void main(String[] args) {
        int[] array = {10,65,21,39,78,12,20,39,39,68};
        selectSearch(array);
    }
}

插入排序

算法描述：将数组分为两个区域，一个是排序区域和未排序区域，在未排序区域中找到最小的元素插入到排序区域中，排序区域中的元素都是按顺序排列，重复上述步骤，直到数组排列完成

步骤：

1. 待插入的元素与前面的元素比较
2. 若待插入元素小于前面的元素，将待插入元素暂存在一个变量中，将前面大于待插入的元素全部向后移动一位
3. 将待插入元素插入空出来的位置
4. 以此循环，直至排序完成

算法实现：

import java.util.Arrays;

public class InsertionSort {
    public static void insertionSort(int[] array){
        for (int i = 1; i < array.length; i++){
            //待插入的元素
            int temp = array[i];
            //待插入元素的前一个元素
            int fornt = i - 1;
            while (fornt >= 0){
                //若待插入元素小于前面的元素，这里不只是前一个元素，是前面所有小于temp的元素
                if (temp < array[fornt]){
                    //将待插入元素前的元素向后移动一位
                    array[fornt + 1] = array[fornt];
                }else {
                    //若没有小于temp的元素，直接结束
                    break;
                }
                //前一个元素移动丸了，还有前前一个元素，以此类推
                fornt--;
            }
            //当跳出while循环后，索引为fornt的元素等于或小于temp，所以将temp插入fornt元素的后面
            array[fornt + 1] = temp;
        }
        System.out.println(Arrays.toString(array));
    }

    public static void main(String[] args) {
        int[] a = {16,49,85,22,16,21,14,10,6,8};
        insertionSort(a);
    }
}