冒泡，选择排序，二分查找

冒泡排序

• 时间复杂度：O(n^2) 稳定

算法步骤

1. 比较相邻元素，如果第一个比第二个大就交换他们。
2. 对每一对相邻元素做同样工作，到结尾后，最后一个元素是最大的数。
3. 重复以上步骤，除开最后一个。

源码如下

    public static void ballSort(int[] a) {
        for (int i = 0; i < a.length - 1; i++) {  //两两比较，所以要少一次
            for (int j = 0; j < a.length - i - 1; j++) {  //排出来的最大值在最右边，每次比较一轮，少一次
                if (a[j] > a[j + 1]) {  
                    int temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
    }

选择排序

• O(n^2) 不稳定

算法步骤

1. 第一位数与后面每一位比较，若大则交换位置，
2. 一轮下来第一位数为最小值。
3. 继续以最小值后面的数开始重复上面的步骤

代码如下：

public static void selectSort(int a[]) {
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = i + 1; j < a.length; j++) {
                if (a[i] > a[j]) {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
    }

java中的排序方法

Arrays.sort(int[] arr, 0,arr.length)

二分查找

时间复杂度log2

算法思路

1. 前提是一个已经排好序的数组
2. mid=(0+arr.length)/2,将mid与要查找的数key比较。
3. 如大于key，则说明key位置在mid左边，反之，在右边。
4. 去出不在的位置，在新的数组中，重复1，2操作。
5. 直到mid=key时，找到结果。

源码：

static  int binarySearch(int[] ay, int num){
        int low = 0,hight=ay.length-1;
        while (low<hight){
            int middle = (low+hight)/2;
            if(ay[middle]==num){
                return middle;
            }
            if(ay[middle]>num){
                hight=middle-1;
            }else{
                low=middle+1;
            }
        }
        return -1;

    }```