比较常见的冒泡、选择排序算法以及折半查找算法

算法

冒泡排序：排序过程中每次从剩下的元素中选出最大值元素放到数组的最后，每次排序通过数组中两两比较，依次比较挑选直到倒数两个数比较完后将数组中最大值放入数组的最后一个元素中。
如：{5,4,7,2,9,6}
第一趟冒泡排序：
第一次比较：{4,5,7,2,9,6}
第二次比较：{4,5,7,2,9,6}
第三次比较：{4,5,2,7,9,6}
第四次比较：{4,5,2,7,9,6}
第五次比较：{4,5,2,7,6,9}
…

public static void sort(int[] ints){
        for (int i = ints.length-1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (ints[j] > ints[j+1]) {
                    int max = ints[j];
                    ints[j] = ints[j+1];
                    ints[j+1] = max;
                }
            }
        }
        for (int i = 0; i < ints.length; i++) {
            System.out.println(ints[i]);
        }
    }

选择排序：每一次从剩余的元素中比较出最小的元素，将其放到数组未排序内容的最前面。相较于冒泡排序来说，选择排序中数组的每一次元素位置交换相比较于冒泡排序来说都是有意义的。其效率比冒泡排序要高。
{2,5,4,7,8,9,1}
第一趟排序：{1,5,4,7,8,9,2}
第二趟排序：{1,2,4,7,8,9,5}
…

package Array;

public class ChoiceSort {
    public static void main(String[] args) {
        sort(new int[]{1,6,3,4,11,23,5,8,22});
    }
    public static void sort(int[] ints){

        for (int i = 0; i < ints.length-1; i++) {
            int min = ints[i];
            int index = i;
            for (int j = i+1; j < ints.length; j++) {
                if (ints[j]<min) {
                    min = ints[j];
                    index = j;
                }
            }
            ints[index] = ints[i];
            ints[i] = min;
            //输出每一趟排序后的数组元素排列
            for (int k = 0; k < ints.length; k++) {
                System.out.print(ints[k] + " ");
            }
            System.out.println();
            System.out.println("=======================================================");
        }
        //输出顺序排序完成后的排序效果
        System.out.println("sort done");
        for (int i = 0; i < ints.length; i++) {
            System.out.print(ints[i] + " ");
        }
    }
}

二分查找法：
在排好序的数组元素的基础上，通过折半的方式去寻找一个元素在数组中的位置，并返回该元素的下标。
a[5] = {1,2,3,4,5}
查找值为1的元素下标：
数组最小下标为0，最大下标为4，则第一次查找的下标为(二分):
(0+4)/2 = 2，则判断a[2]即3是否等于1，不等则看a[2]是大于还是小于1，如果大于，则代表要找的数在左边，则用(0+2)/2 = 1 ，1为下一次比较的元素下标；如果是小于，则代表要找的数在右边，此时用(2+4)/2 = 3，3为下一次比较的元素下标。
比较下面两种代码：
开头的是我写的代码，后面的是标准代码。

 public static int slt(int[] ints,int value){
        int flag = ints.length / 2; 
        int left = 0; 
        int right = ints.length; 
        //
        while (ints[flag] != value){
            if(left + 1 == right) {
                System.out.println("break!");
                break;
            }
            if (ints[flag] > value){
                right = flag;
                flag = (left + right) / 2;
                System.out.println(flag);
            }
            else {
                left = flag;
                flag = (flag + right) / 2;
                System.out.println(flag);
            }
        }
        System.out.println(ints[flag]);
        return flag;
    }

 public static int binarySearch(int[] ints,int key){
        int low = 0,high = ints.length,mid = (low + high) / 2;
        while (low <= high){
            mid = (low + high) / 2;
            if (ints[mid] == key){
                return mid;
            }else if (ints[mid] > key){
                high = mid - 1;
            }else low = mid + 1;
        }
        return -1;
    }