冒泡排序，快速排序，插入排序，选择排序，二分查找

import java.util.Arrays;
public class Test9 {
    public static void main(String[] args) {
        int[] arr = {6,14,2,11,7,5,10,8,9};
        //bubble(arr);
        //selection(arr);
        InsertionSorting(arr);
        //Quicksort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
       int number = 6;//要查找的元素
       System.out.println("要找的元素的下标是："+BinarySearch(arr, 6));
    }

    //冒泡排序
    public static void bubble(int[] arr) {
        int temp;
        for (int i = arr.length-1; i>=0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    //选择排序
    public static void selection(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            int ArrayMin = i;
            for (int j = (i + 1); j < arr.length; j++) {
                if (arr[j] < arr[ArrayMin]) {
                    ArrayMin = j;
                }
            }
            if (ArrayMin != i) {//注意if判断(元素交换）在内循环外，在外循环内，而冒泡排序if判断元素交换在内循环内
                temp = arr[i];
                arr[i] = arr[ArrayMin];
                arr[ArrayMin] = temp;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    //插入排序
    public static void InsertionSorting(int[]arr){
        for(int i =1;i<arr.length;i++){
             int temp = arr[i];
             int j = i-1;
             while(j>=0&&arr[j]>temp){
                 arr[j+1] = arr[j];
                 j--;
             }
             arr[j+1] = temp;
        }
    }

    //二分查找
    public static int BinarySearch(int[] arr, int number) {
        int Front = 0;
        int last = arr.length - 1;
        while (Front <= last) {
            int mid = (Front + last) / 2;
            if(arr[mid]==number){
                return mid;
            }
            if (arr[mid] < number) {
                Front = mid + 1;
            }
            if (arr[mid] > number) {
                last = mid - 1;
            }
        }
        return -1;
    }
    //快速排序
    public static void Quicksort(int[]arr,int left,int right){
        if(left>=right){// bug:left<=right 判断是否合法
            return;
        }
        int base = arr[left];
        int i = left;
        int j = right;
        int temp;
        while(i!=j){  //如果i=j了说明重叠了，bug :i<j
            while(arr[j]>=base&&i<j){ //j<j不能丢失
                j--;
            }
            while(arr[i]<=base&&i<j){ //g:base>arr[i]&&i<j 元素相等时i也增值
                i++;
            }
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //当i和j相等时，就可以将中值放在中间i和j重合的地方
        arr[left] = arr[i];
        arr[i]= base;   //g:arr[i] = arr[left] 这样写的话会导致 arr[left]元素丢失，元素交换时应先用一个变量保存元素

        Quicksort(arr,left,i-1);
        Quicksort(arr,i+1,right);

    }
}