Java 中的几个算法

一、冒泡排序、插入排序、希尔排序、快速排序与归并排序

效率概要：

冒泡排序是蛮力法，使用两层嵌套循环，基本效率为 O(n^2)

插入排序是减治法，第一趟排序，最多比较一次，第二趟排序，最多比较两次，以此类推，最后一趟最多比较N-1次，因此有1+2+3+…+N-1 = N*(N-1)/2。然而，因为在每一趟排序发现插入点之前，平均只有全体数据项的一半真的进行了比较，所以除以2最后是N*(N-1)/4。 
对于随机顺序的数据，插入排序也需要O（N²）的时间级。当数据基本有序，插入排序几乎只需要O(N)的时间，这对把一个基本有序的文件进行排序是一个简单而有效的方法。 
对于逆序排列的数据，每次比较和移动都会执行，所以插入排序不比冒泡排序快。

快速排序是分治法，治的时间效率为 O(n),  分的时间效率为 O(log(n))，总效率为 O(nlog(n))

冒泡排序

public class Demo {
    private int[] arr = {9, 8, 2, 4, 6};

    @Test
    public void test() {
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[i]) {
                    int p = arr[i];
                    arr[i] = arr[j];
                    arr[j] = p;
                }
            }
        }
    }
}

一次循环确立一个值 O(n)，需要 n 次循环，总共是 O(n^2)

插入排序（推进法、减治法）

public class Demo {

    @Test
    public void test() {
        int[] arr = {9, 8, 2, 4, 6};
        insert_sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private void insert_sort(int[] arr) {
        for (int i = 0; i <= arr.length - 1; i++) {
            int key = arr[i]; //建立一个瘪
            int j = i - 1; //建立一个吃瘪游标
            for (; j >= 0 && arr[j] > key; j--) {
                arr[j+1] = arr[j]; // 大的数往右推
            }
            arr[j + 1] = key; // 没小的数没得推，只能吃瘪
        }
    }

}

这个算法从数组的第二个元素开始循环，将选中的元素与之前的元素一一比较，如果选中的元素小于之前的元素，则将之前的元素后移，最后再将选中的元素放在合适的位置。在这个算法执行的过程中，总是保持着索引i之前的数组是升序排列的。

总共比较了 (1+2+3+…+N-1) / 2 次，所以效率是 N*(N-1)/4。平均效率为 O(n^2)

总数 少于 47，使用插入排序。

　

快速排序

public class Demo {

    @Test
    public void test() {
        int[] nums = {9, 8, 2, 4, 6};
        quickSort(nums, 0, 4);
        System.out.println(Arrays.toString(nums));
    }

    private void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int mid = getMiddle(arr, low, high);
            quickSort(arr, low, mid - 1);
            quickSort(arr, mid + 1, high);
        }
    }

    private int getMiddle(int[] arr, int low, int high) {
        int pivot = arr[low];
        while (low < high) {
            while (low < high && arr[high] >= pivot) high--;
            arr[low] = arr[high];
            while (low < high && arr[low] < pivot) low++;
            arr[high] = arr[low];
        }
        arr[low] = pivot;
        return low;
    }

}

分治法：一次确立一个数处于中间位置 O(n)，这个中间数的两边分别再次确立同样的中间数，依次推进直到所有数都确立完毕 O(logn)，总共是 O(nlog(n))

归并排序

public class Demo {

    @Test
    public void test() {
        int[] arr = {9, 8, 2, 4, 6, 4};
        merge_sort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    private void merge_sort(int[] arr, int left, int right) {
        if (left < right) {
            int center = (left + right) / 2;
            merge_sort(arr, left, center);
            merge_sort(arr, center + 1, right);
            merge(arr, left, center, right);
        }
    }

    private static void merge(int[] a, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low, j = mid + 1, k = 0;

        while (i <= mid && j <= high) {                          // 把两个数组中较小的数先移到新数组中
            if (a[i] < a[j]) {
                temp[k++] = a[i++];
            } else {
                temp[k++] = a[j++];
            }
        }

        while (i <= mid) {                                       // 把左边剩余的数移入数组
            temp[k++] = a[i++];
        }

        while (j <= high) {                                      // 把右边边剩余的数移入数组
            temp[k++] = a[j++];
        }

        for (int k2 = 0; k2 < temp.length; k2++) {               // 把原数组替换为新数组
            a[k2 + low] = temp[k2];
        }
    }

}

原理

二、常见问题

概述：

1. 折半查找（二分法）

运用了减治法

public class Test {
    private static int[] arr = new int[]{29, 12, 78, 23, 18, 24, 78, 23, 43};

    @org.junit.Test
    public void binarySearch() {
        Arrays.sort(arr);
        System.out.println(find(arr, 3));
    }

    private int find(int[] arr, int key) {
        return find(arr, key, 0, arr.length -1);
    }

    private int find(int[] arr, int key, int low, int high) {
        if (low <= high) {
            int mid = (low + high) >>> 1;
            int midVal = arr[mid];
            if (midVal == key) {
                return mid;
            } else if (key < midVal) {
                return find(arr, key, low, mid - 1);
            } else {
                return find(arr, key, mid + 1, high);
            }
        } else {
            return -(low + 1);
        }
    }

}

2. 求数组最大值位置

运用了分治法

public class Test {
    private static int[] arr = new int[]{29, 12, 38, 23, 98, 24, 28, 23, 43};

    @org.junit.Test
    public void test() {
        int maxInt = max(0, arr.length - 1);
        System.out.println(maxInt);
    }

    private int max(int low, int high) {
        if (low < high) {
            int mid = (low + high) >>> 1;
            int m1 = max(low, mid);
            int m2 = max(mid + 1, high);
            return arr[m1] > arr[m2] ? m1 : m2;
        } else {
            return low;
        }
    }

}

　　

待日后总结：https://my.oschina.net/lemos/blog/1932171