常见的算法及其复杂度分析

public class Singleton1 {
    public static void main(String args[]) throws Exception {

    //二分查找
        int[] a={2,3,14,5,6,17,8,2,3,33,24};
        System.out.println(Singleton1.getfirstdiaapear(a));
        int param=7;
        System.out.println(Singleton1.gethalf(a,param));
        //冒泡排序
        int[] result=getBubbleSort(a);
        for(int i:result){
            System.out.println(i);
        }

//       int[] params=getSelectSort(a);
//        for(int pa:params){
//            System.out.println(pa);
//        }
    }
    //选择排序
    public static int[] getBubbleSort(int[] a){
        for(int i=0;i<a.length-1;i++){
            for(int j=i+1;j<a.length;j++){
                if(a[j]>a[i]){
                    int temp=a[j];
                    a[j]=a[i];
                    a[i]=temp;
                }
            }
        }
        return a;
    }
    //选择排序
    public static  int[]  getSelectSort(int[] a){
        for(int i=0;i<a.length-1;i++){
            int min=a[0];
            for(int j=i+1;j<a.length;i++){
                if(a[j]<min){
                    j=min;
                }
                if(i!=j){
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }
        }
        return a;
    }
    //二分查找
    public static   boolean gethalf(int[] source,int param){
        boolean flag=false;
        int start=0,end=source.length,middle=0;
        while(start<end){
            middle=(start+end)/2;
            if(source[middle]>param){
                end=middle-1;
            }
            else if(source[middle]<param){
                start=middle+1;
            }
          else{
                flag=true;
            }
        }
        return flag;
    }
    //找出第一个仅出现一次的数字
    public  static int getfirstdiaapear(int[] a){
        int result=0,count=0;
        boolean flag=false;
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a.length;j++){
                if(i!=j&&a[i]==a[j]){
                    break;
                }else{
                    flag=true;
                    count++;
                }
            }
            if(flag==true&&count==1) {
                result = a[i];
            }
        }

        return result;
    }
  //合并两个有序的数组,组合成新的数组
    public int[] getNewdata(int[] a1,int[] a2){
        int[] newdata=new int[a1.length+a2.length];

        for(int i=0;i<a1.length;i++){
            if(a1[i]>a2[i]) {
                newdata[i] = a2[i];

                if (a2[i+1]>a1[i]){
                    newdata[i+1]=a1[i];
            }
            else{
                    if(a1[i]<a2[i]){
                        newdata[i]=a1[i];
                        if (a2[i+1]<a1[i]){
                            newdata[i+1]=a2[i+1];
                        }
                    }
                }
            }
        }

        return null;
    }
//找出一个数,比他大的放在他后面,比他小的放在他前面
    public int[] getMoreorLess(int[] param){
          for(int i=0;i<param.length;i++){
              if(param[i]<param[3]){
                  i--;
              }
          }

        return null;
    }
    void quickSort(int[] data, int length, int start, int end) {
            if (start == end) {
                return;
            }
            // 选择的数经过一次排序后所在的位置下标
            int index = Partition(data, length, start, end); // 由上述Partition可知以最后一个元素为基准元素
            // 递归把选择数字左边排序
            if (index > start) {
                quickSort(data, length, start, index - 1); // 先排基准元素前面部分
            }
            // 递归把选择数字右边排序
            if (index < end) {
                quickSort(data, length, index + 1, end); // 后排基准元素后面部分
            }
        }

        // 在数组中选择一个数，比选择的数字小的数字移到数组的左边，比选择数字大的移动到数组的右边
        int Partition(int[] data, int length, int start, int end) {
            if (data.length == 0 || length <= 0 || start < 0 || end >= length) {

                return -1;
            }
            // 选择从最后一个数为基准元素开始一次排序
            int index = start - 1;
            for (int i = start; i < end; ++i) {
                if (data[i] < data[end]) // 以最后一个元素为基准点进行划分
                {
                    ++index;
                    if (index != i) {
                        // 交换
                        int temp = data[i];
                        data[i] = data[index];
                        data[index] = temp;
                    }
                }
            }

            ++index;
            // 交换
            int temp = data[index];
            data[index] = data[end];
            data[end] = temp;
            // System.out.print("index=" + index + " ");
            return index; // 返回一次排序后开始选择的数此刻所在最终位置索引
        }