java常用排序、查找整理

冒泡排序

  public static void BubbleSort(int[] arr) {
        int temp;//定义一个临时变量
        for(int i=0;i<arr.length-1;i++){//冒泡趟数
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j+1]<arr[j]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

插入排序

   public static void insertionSort(int [] array){
        int current;//当前要排序的数
        for (int i = 1; i < array.length; i++) {//控制比较的趟数
            current=array[i];//取出要排序的数
            int preIndex = i-1;//要排序的数的前一个的下标
            //控制当前数与前面的数进行比较
            while (preIndex>=0&&current<array[preIndex]) {
                array[preIndex+1]=array[preIndex];
                preIndex--;
            }
            array[preIndex+1]=current;
        }
    }

选择排序

  /**
 * 选择排序
 * @param array
 */
public static void selectionSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {//控制比较的趟数
        int minIndex = i;
        for (int j = i + 1; j < array.length; j++) {//控制每趟比较次数
            if (array[minIndex] > array[j]) {//如果比minIndex的数小，则取出该下标作为minIndex
                minIndex = j;
            }
        }
        if (minIndex != i) {//如果i位置不是最小值，则交换位置
            int temp = array[i];
            array[i] = array[minIndex];
            array[minIndex] = temp;
        }
    }
}

快速排序

/**
 * 快速排序算法
 * @param arr
 * @param low
 * @param high
 */
public static void quickSort(int[] arr, int low, int high) {
    int i, j, temp, t;
    if (low > high) {
        return;
    }
    i = low;
    j = high;
    //temp就是基准位
    temp = arr[low];
    while (i < j) {
        //先看右边，依次往左递减
        while (temp <= arr[j] && i < j) {
            j--;
        }
        //再看左边，依次往右递增
        while (temp >= arr[i] && i < j) {
            i++;
        }
        //如果满足条件则交换
        if (i < j) {
            t = arr[j];
            arr[j] = arr[i];
            arr[i] = t;
        }
    }
    //最后将基准为与i和j相等位置的数字交换
    arr[low] = arr[i];
    arr[i] = temp;
    //递归调用左半数组
    quickSort(arr, low, j - 1);
    //递归调用右半数组
    quickSort(arr, j + 1, high);
}

二分查找

/**
 * 二分查找
 * @param arr 已升序排序好的数组
 * @param key 要查的数
 * @return 所在位置, -1不存在
 */
int bsearchWithoutRecursion(int arr[], int key) {
    int low = 0;
    int high = arr.length - 1;
    while (low <= high) {
        int mid = low + (high - low) / 2;
        if (arr[mid] > key) {
            high = mid - 1;
        } else if (arr[mid] < key) {
            low = mid + 1;
        } else {
            return mid;
        }
    }
    return -1;
}