常见算法简介及实现

1、选择排序
选择排序是一种基础、稳定的排序算法，用第一个元素V1和其他所有元素一个一个对比，比较出最小的元素Vmin，再把V1与Vmin的数组下标位置交换；之后第二个再和剩下的所有元素比较 …，这样一直循环比较整个数组，即可得到一个有序的数组。时间复杂度为n的2次方。
实现代码（java）：

    public static void xuanze_sort(){
        int data []={1,3,2,22,33,4,6,5};
        for(int i=0;i<data.length;i++){
            for(int j=i+1;j<data.length;j++){
                if(data[i]>data[j]){
                    int temp=data[j];
                    data[j]=data[i];
                    data[i]=temp;
                }
            }
        }
        for (int t : data) {
            System.out.println(t);
        }
    }

2、冒泡排序
冒泡排序也是一种常见的排序算法，通过把相邻元素两两对比并交换的方式，先找出最大的元素放到数组末尾，再比较出第二大的元素…，从而循环比较出整个有序的数组。时间复杂度为n的2次方。
实现代码（java）：

    public static void maopao_sort() {
        int data[] ={2,1,5,4,33,3,6};
        for(int i=0;i<data.length-1;i++){
            for(int j=0;j<data.length-1-i;j++){
                if(data[j]>data[j+1]){
                    int temp=data[j];
                    data[j]=data[j+1];
                    data[j+1]=temp;
                }
            }
        }
        for (int t : data) {
            System.out.println(t);
        }
    }

3、二分查找算法
也叫做折半查找，被广泛运用在各开源框架的底层技术，比如数据库的索引等。
实现方式：

   //二分查找，对有序数组快速查找其中的某个元素的下标,时间复杂度为log2n
//    如果能找到元素则返回元素对应的下标，否则返回-1
    public static int half_find(int []arr,int key){
        int low =0;
        int high=arr.length-1;
        int middle=0;
        if(key<arr[low] || key>arr[high] || arr.length==0){
            //未找到或数组为空
            return -1;
        }
        while(low<=high){
            //中间下标
            middle=(high+low)/2;
            if(key>arr[middle]){
                low=middle+1;
            }else if (key<arr[middle]){
                high=middle-1;
            }else{
                return middle;
            }
        }
        return -1;
    }