数据结构——排序

1、有序数组二分查找

   首先设定判断要找的数据为key,判断其是否在 数组的中间即a.length/2的位置，即key=a[a.length/2] 如果在直接返回。如果不在则循环获取，重要的一点，中间元素的值为mid = start + (start + end)/2。 判断如果key在mid位置则 返回，如果key>a[mid] 则start=mid +1;反之则为end = mid -1; 核心代码如下：

//如果在有序数组的中间直接返回
        int mid=a.length/2;
        if (key==a[mid]) {
            return mid;
        }
        int start=0;
        int end=a.length-1;

        while (start <= end) {
            //每次定位中间位置
            mid = start+(end-start)/2;
            
            if(key == a[mid]){
                return mid;
            }else if(key > a[mid]){
                start = mid +1;
            }else{
                end = mid-1;
            }
        }
        return -1;

//递归查找

private static int binSearch(int[] a, int start,int end,int key){
        int mid = (end - start)/2 +start;
        if(a[mid] == key){
            return mid;
        }else if(start >= end){
            return -1;
        }else if(a[mid] > key ){
            return binSearch(a, start,mid -1,key);
        }else{
            return binSearch(a,mid + 1, end,key);
        }
    }

2、冒泡排序

     冒泡排序是简单排序里面效率最小的一种排序方式，假如有n个数据，外层循环n-1次。每次相比较n-i次，重点在于：如果a[j]>a[j+1]，则缓存temp=a[j+1],交换a[j]和a[j+1],核心代码如下：

//外层循环控制排序趟数(n-1)趟
        for (int i = 0; i < a.length -1 ; i++) {
            for (int j = 0; j < a.length -1 -i; j++) {    //每一趟排序多少次n - i趟
                if(a[j]>a[j+1]){
                    long temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }

3、选择排序

     选择排序 效率比冒泡排序的效率高一些，主要思想是当前的数据记录为最小值min和接下来的数据做对比，如果接下来的数据比当前的小，则记录此数据为最小值，接着向下比较，每一次循环找到一个数据最小的值，交换。核心代码如下

//外层循环控制排序趟数(n-1)趟
        int in,out,min;
        for (out = 0; out < mElement ; out++) {
            min = out;
            for (in = out+1; in < mElement; in++) {    //从下一个数据开始
                if(a[in]<a[min]){
                    min = in;
                }
            }
            long temp = a[out];
            a[out] = a[min];
            a[min] = temp;
        }

4、插入排序

     定义一个临时存储的变量，将数据列表中第二个数据放入零时变量中，然后依次和它之前的数据比较，前一条数据如果大于等于temp的话移动，否则不移动。 定义一个临时变量为temp, 核心代码如下：

//插入排序 --将第二个数据放入零时变量中，往取出数据的当前位置往前移动， 比较大小，放入相应的位置
        int out,in;
        for (out = 1; out <mElement; out++) {
            long temp = a[out];
            in = out;   
            while( in >0 && a[in-1]>=temp){  //往前循环， 判断为：in不能越界， 前一条数据如果大于等于temp的话移动。 否则不移动
                a[in] = a[in-1];
                in--;
            }  //至此就移动结束
            a[in]=temp;
        }