java开发面试常用的算法

二分查找：要求数组已经是排好序的。（例子从小到大排好序），在数组中找出key值的索引。

public int binarySearch(int[] array, int key) {
    int low = 0;
    int high = array.length-1;
    int mid = -1; 
    while(low < high) {
        mid = (low + high)/2;
        if(array[mid] == key)
            return mid;
        else if(array[mid]<key)
            low = mid + 1;
        else
            high = mid - 1;
    }
    return -1； 
}

冒泡排序：每趟进行两两比较，每次能识别出最大的一个元素。

public void Bubblesort(int[] array) {
    int temp;
    int len = array.length;
    for(int i=0;i<len-1; i++) { 
        for(int j=len-1; j>i; j--) {  ///!!!!!!!
            if(a[j] < a[j-1]) {
                temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
        }
    }
}

选择排序：选最小，作交换。

第一轮经过比较得出最小的元素，然后与第一个位置的元素进行交换；第二轮从不包括第一个元素以外的记录中找最小的，与第二个位置元素进行交换，直到待比较的记录有一个为止。

public void selectSort(int[] array) {
    int flag = 0; //记录最小值的位置
    int temp;  //记录每步查找的最小值
    for(int i=0; i<array.length; i++) {
        temp =array[i];
        for(int j=i+1; j<array.length; j++) {
            if(temp > array[j]) {
                temp =array[j];
                flag = j;
            }
        }
        if(flag != i) {
            a[flag] = a[i];
            a[i] = temp;
        }
    }
}

快速排序：分左右，递归排。

将数组分成两部分（依据目标值，目标值一般选择第一个位置的元素）。一次比较，小的放在左面，大的放在右面。之后左右两面分别再进行相同的处理。

public void sort(int[] array, int begin, int end) {
    int i = begin;
    int j = end;
    int temp = array[i];
    while(i < j) {
        while(i<j &&　array[j] >= temp)
            j --;
        if(i < j)
            array[i++] = array[j];
        while(i<j && array[i] < temp)
            i ++;
        if(i < j)
            array[j --] = array[i];
    }
    a[i] = temp;
    sort(array, begin, i-1);
    sort(array, i+1, end);
}

public void quickSort(int[] array) {
    int len = array.length;
    sort(array, 0, len-1);
}

插入排序：第一个元素默认有序。后面依次插入，插入时必须保证有序。

public void insertSort(int[] array) {
    int temp;
    int j;
    for(int i=0; i<array.length; i++) {
        temp = array[i];
        j = i;
        if(array[j-1] > temp) {
            while(j>=1 &&　array[j-1] > temp）｛ //一直向前比较
                array[j] = array[j-1];
                j--;
            ｝
        }
        array[j]=temp;
    }
}

希尔排序：与插入排序类似，只不过在外面有一个步长序列，控制插入排序的次数。

public void shellSort(int[] array) {
    int temp;
    int j;
    for(int h=array.length/2; h>0; h/=2) {  //步长序列
        for(int i=h; i<array.lenth; i++) {  //插入排序
            temp = array[i];
            for(int j=i-h;j>=0; j-=h) {
                if(array[j] > temp)
                    array[i+h] = array[j];
            }
        }
    }
}

归并排序：划分，合并。

首先将两个长度为一的子序列归并，之后将所有归并的结果再看成一个整体，两两归并。

关键在于第一步划分半子表，第二步合并半子表。

public void merge(int[] array, int begin, int mid, int end){
    int lenL = mid-begin+1;
    int lenR = end - mid;
    int[] left = new int[lenL];
    int[] right = new int[lenR];
    int k ;
    for(int i=0,k=begin; i<lenL; i++) 
        left[i] = array[k++];
    for(int j=0,k=mid+1; j<lenR; j++)
        right[j] = array[k++];
    for(k=begin,i=0,j=0; i<lenL&&j<lenR; k++) {
        if(left[i] > right[j]) {
            array[k] = right[j];
            j++;
        }
        else {
            array[k] = left[i];
            i++;
        }
    }
    if(i < lenL) {
        for(j=i; j<lenL; j++)
        array[k++] = left[j];
    }
    if(j < lenR) {
        for(i=j; i<lenR; i++)
        array[k++] = right[i];
    }
}

public void quickSort(int[] array, int begin, int end) {
    if(begin < end) {
        int mid = (end + begin)/ 2;
        quickSort(array, begin, mid);
        quickSort(array, mid+1, end);  //分
        merge(array, begin, mid, end);  //并
    }
}

java开发面试常用的算法

猜你喜欢