排序算法之选择、插入、冒泡、快速

三个类：

AbstractSortService ：

package cn.zhi.sort;

public abstract class AbstractSortService {

    public void swap(int[] array, int i, int j) {
        if (i != j) {
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }

    public void print(int[] arr) {
        for (int i : arr) {
            System.out.print(" " + i);
        }
    }

    public void print(int[] arr, int middle) {
        print(arr);
        System.out.println(" __:" + middle);
    }

    public void print(int[] arr, int i, int middle) {
        print(arr);
        System.out.println(" __: " + i + ":" + middle);
    }

}

package cn.zhi.sort;

public class SortImpl extends AbstractSortService {

    /**
     * 选择排序，O(n^2)，从你一个位置开始，依次选出未排序的最小值和游标交换，交换次数O(n)。
     *
     * @param arr
     */
    public void select(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int minV = arr[i];
            int min = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < minV) {
                    min = j;
                    minV = arr[j];
                }
            }
            swap(arr, i, min);
        }
    }

    /**
     * 插入排序，同样也是O(n^2) 一层一层地排好序,最好排到最外层结束。
     *
     * @param arr
     */
    public void insert(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
                swap(arr, j, j - 1);
            }
            // for (int j = i; j > 0; j--) {
            // if (arr[j] < arr[j - 1]) {
            // swap(arr, j, j - 1);
            // } else {
            // break;// 只判断相邻两个元素
            // }
            // }
        }
    }

    /**
     * 冒泡排序， 交换相邻元素 O(n^2) 从第一颗气泡开始冒泡，内层循环结束：最大的气泡浮出水面
     *
     * @param arr
     */
    public void bubble(int[] arr) {
        for (int i = arr.length; i >= 0; i--) {
            for (int j = 1; j < i && arr[j] < arr[j - 1]; j++) {
                swap(arr, j, j - 1);
            }
        }
    }

    /**
     * 快速排序，复杂度 nlog2(n),算是对冒泡排序的一种优化
     *
     * @param arr
     * @param left
     * @param right
     */
    public void quick(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int l = left, h = right;
        int m = l, middle = arr[m];

        while (l < h) {
            while (m < h && arr[h] > middle) {
                h--;
            }
            swap(arr, m, h);
            m = h;
            while (l < m && arr[l] <= middle) {//注意此处应该是<=，否则数组有相同元素时会死循环
                l++;
            }
            swap(arr, m, l);
            m = l;
        }
        quick(arr, left, m - 1); // 对低字段表进行递归排序
        quick(arr, m + 1, right); // 对高字段表进行递归排序
    }

}

package cn.zhi.sort;

public class Test {
    public static void main(String[] args) {
        int[] arr = new int[] { 41, 43,78,21,89, 3,233,81,0,42,93,89,12,};
        SortImpl sort = new SortImpl();

        sort.print(arr);
        System.out.println();

//        sort.select(arr);
//        sort.insert(arr);
//        sort.bubble(arr);
        sort.quick(arr, 0, arr.length-1);

        sort.print(arr);
    }
}

输出结果：

 41 43 78 21 89 3 233 81 0 42 93 89 12
 0 3 12 21 41 42 43 78 81 89 89 93 233