二分查找法

属于递归查找的一种,只适用于从有序的数列中进行查找

public class binarySearch {
    public static int binarySearch(int [] array ,int a){

        int low=0;
        int high=array.length-1;
        int mid;
        while(low<=high){
            mid=(low+high)/2;
            if(array[mid]==a){
                return mid;
            }else if(a>array[mid]){
                low=mid+1;
            }else{
                high=mid-1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] array=new int[]{1,2,3,4,5,6,7,8,9};
        int mid=binarySearch(array,7);
        System.out.println(mid);
    }}
    
    结果是6

冒泡排序

两个相邻的数比较大小，将两个数中较大的数往右边放，小的往左边放

public class bubbleAlgorithm {
    //冒泡排序方法:
    public static int[] bubblesort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        //外层循环控制排序趟输
        //第一趟下来，最大的移动到右边了
        for (int i = 0; i < arr.length - 1; i++) {
            //内层循环控制每一趟排序多少次
            boolean isSorted  = true;//有序标记，每一轮的初始是true
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
           // 如果在本轮排序中，元素有交换，则说明数列无序；如果没有元素交换，说明数列已然有序，直接跳出大循环。
            if(isSorted )
                break;
        }
        return arr;
    }

对以上冒泡排序方法进行优化

    
    public static int[] bubbleSort1(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
//记录最后一次交换的位置
        int lastExchangeIndex = 0;
//无序数列的边界，每次比较只需要比到这里为止
//在每一轮排序的最后，记录一下最后一次元素交换的位置，那个位置也就是无序数列的边界，再往后就是有序区了。
      
        int sortBorder = arr.length - 1;
        for (int i = 0; i < arr.length - 1; i++) {
            boolean isSorted  = true;//有序标记，每一轮的初始是true
            System.out.println("sortBorder==="+sortBorder);
            for (int j = 0; j < sortBorder; j++) {
                if (arr[j + 1] < arr[j]) {
                    isSorted  = false;//有元素交换，所以不是有序，标记变为false
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                    lastExchangeIndex = j;
                }
            }
            sortBorder = lastExchangeIndex;
            //一趟下来是否发生位置交换，如果没有交换直接跳出大循环
            if(isSorted )
                break;
        }
        return arr;
    }
    public static void main(String[] args) {
        int[] array = new int[]{1,2,5,4,3,8,9};
        //int[] arr = bubblesort(array);
        int[] arr =bubbleSort1(array);
        for (int i : arr) {
            System.out.println(i);
        }

    }
}
//结果：6