最最最最基本算法(一)--

顺序查找

时间复杂度为O(n);

public class solution{
    public static int orderFind(int[] sz,int key){
        for(int i=0;i<sz.length;i++){
            if(sz[i]==key) return i;
        }
        return -1;
    }
}

折半查找

时间复杂度为O(log 2 n);

publick class Solution{
    public static int BinarySerach(int[] sz,int key){
        int low =0;
        int high=sz.length-1;
        while(low<=high){
            int middle=(high+low)/2;
            if(sz[middle]==key) 
            return middle;
            if(key<sz[middle]){high=middle-1}
            else if(key<sz[middle]){
            low =middle+1;
            }
        }
        return -1;
    }
}

冒泡排序

时间复杂度为O(N!)

    public int[] sort(int[] ss){
        //最外层循环,从大到小进行遍历操作>>意义:每一遍至少会将最大的数移位到最后
        for(int i=ss.length-1;i>0;i--){
        //第二层循环,以i为遍历次数 
            for(int j=0;j<i;j++){
                //比较
                if(ss[j]>ss[j+1]){
                    int temp =ss[j];
                    ss[j]=ss[j+1];
                    ss[j+1]=temp;
                }
            }
        }
        return ss;
    }

选择排序

    //选择排序
    //总体来说,思路和冒泡排序相同,算是冒泡排序的优化版
    public static void selectedSort(int[] ss){
        int len=ss.length;
        for(int i=0,k=0;i<len;i++,k=i){
            //如果有后面数小于前面的数,则对调
            for(int j=i+1;j<len;j++){
                if(ss[k]>ss[j])
                    k=j;
                if(i!=k){
                    swap(ss,i,k);
                }
            }
        }
    }

快速排序

最大时间复杂为O(n^2);

    //快速排序
    public static void quicklySort(int[] ss,int start,int end){
        //排序至少元素数量要大于1
        if((end-start)>1){
            int mid=0;
            mid=divider(ss,start,end);
            quicklySort(ss,start,mid);
            quicklySort(ss,mid+1,end);
        }
    }
    //排序:选择传入数组的第一个元素为标准,大于标准的放其右边边,反之亦然
    public static int divider(int[] ss,int start,int end){
        //选择第一个元素作为标准
        int pivot=ss[start];
        //当start=end的时候,排序结束
        while(start<end){
            //从右往左寻找小于标准值的元素,如果找到则进行替换
            while(start<end&&ss[end]>=pivot)
                //将右边的值左移一位
                end--;
            if(start<end){
                swap(ss,start,end);
                start++;
            }
            //从左往右寻找大于标准值的元素,如果找到则进行替换
            while(start<end&&ss[start]<pivot)
                //将左边的值右移一位
                start++;
            if(start<end){
                swap(ss,start,end);
            }
        }
//      ss[start]=pivot;
        return start;
    }
    //将数组的两个元素进行交换
    public static void swap(int[] ss,int start,int end){
        int temp=ss[end];
        ss[end]=ss[start];
        ss[start]=temp;
    }