多种排序算法-java实现

常见的排序算法

1.冒泡排序

public static int[] 冒泡排序(int[] array) {
        if (array.length > 0) {
            for (int i = 0; i < array.length; i++) {
            // 每次最大元素就像气泡一样"浮"到数组的最后
                for (int j = array.length - 1; j > i; j--) {
                // 依次比较相邻的两个元素,使较大的那个向后移
                    if(array[j]<array[j-1]){
                        int item = array[j];
                        array[j]= array[j-1];
                        array[j-1] = item;
                    }
                }
            }
        }
        return array;
    }

2.定向冒泡排序（鸡尾酒排序）

public static int[] 定向冒泡排序(int[] array) {
        int left = 0;
        int right = array.length - 1;
        while (left < right) {
            //左边，最大数右移
            for (int i = left; i < right; i++) {
                if (array[i] > array[i + 1]) {
                    int temp = array[i];
                    array[i] = array[i + 1];
                    array[i + 1] = temp;
                }
            }
            right--;
            //右边，小数左移
            for (int i = right; i > left; i--) {
                if (array[i - 1] > array[i]) {
                    int temp = array[i];
                    array[i] = array[i - 1];
                    array[i - 1] = temp;
                }
            }
            left++;
        }
        return array;
    }

3.选择排序
选择排序与冒泡排序的区别：冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。选择排序是不稳定的排序算法，不稳定发生在最小元素与A[i]交换的时刻。

public static int[] 选择排序(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int min = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[min]) {
                    min = j;
                }
            }
            if (min != i) {
                int item = array[i];
                array[i] = array[min];
                array[min] = item;
            }
        }
        return array;
    }

4.插入排序
插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，比如量级小于千，那么插入排序还是一个不错的选择。 插入排序在工业级库中也有着广泛的应用，在STL的sort算法和stdlib的qsort算法中，都将插入排序作为快速排序的补充，用于少量元素的排序（通常为8个或以下）

public static int[] 插入排序(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int get = array[i];
            int j = i - 1;
            while (j >= 0 && array[j] > get) {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = get;
        }
        return array;
    }

5.二分插入排序
当n较大时，二分插入排序的比较次数比直接插入排序的最差情况好得多，但比直接插入排序的最好情况要差，所当以元素初始序列已经接近升序时，直接插入排序比二分插入排序比较次数少。二分插入排序元素移动次数与直接插入排序相同，依赖于元素初始序列。

 public static int[] 二分插入排序(int[] array) {
        for (int i = 0; i < array.length; i++) {
            int get = array[i];
            int left = 0;
            int right = i - 1;
            while (left <= right) {
                int mid = (left + right) / 2;
                if (array[mid] > get) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            }
            for (int j = i - 1; j >= left; j--) {
                array[j + 1] = array[j];
            }
            array[left] = get;
        }
        return array;
    }