常见的算法及其复杂度

个人分类： java
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(flagtrue&&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; // 返回一次排序后开始选择的数此刻所在最终位置索引
    }