参考 http://www.cyc2018.xyz/

1. 所有排序算法实现Sort 抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public abstract class Sort<T extends Comparable<T>> {
    public abstract void sort(T[] numbs);

    /**
     * 实现compare 接口， 用于比较数据的大小
     *
     * @param v 数值1
     * @param w 数值2
     * @return v < w (true)
     */
    protected boolean less(T v, T w) {
        return v.compareTo(w) < 0;
    }


    /**
     * 交换数组两个位置的值
     *
     * @param a 待交换的数组
     * @param i 位置i
     * @param j 位置j
     */
    protected void swap(T[] a, int i, int j) {
        T t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}

2. 选择排序

将 第一位 与后面的数字逐一比较, 若找到比 第一位小的， 则交换位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * 选择排序
 * 例子: 1,2,0,-1,2
 * a. 1, (2, 0, -1, 2)  (将 第一位 与后面的数字逐一比较, 若找到比 第一位小的， 则交换位置)<br/>
 * b. -1, 2, (0 ,1, 2) <br/>
 * c. -1, 0, 2, (1, 2) <br/>
 * d. -1, 0, 1, (2, 2) <br/>
 * e. -1, 0, 1, 2, (2) <br/>
 */
 public void sort(T[] numbs) {
        // 逐次寻找各位的数字, 直到倒数第二位
        for (int i = 0; i < numbs.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < numbs.length; j++) {
                if (less(numbs[j], numbs[min])) {
                    min = j;
                }
            }
            swap(numbs, i, min);
        }
    }

3. 冒泡排序

通过循环依次交换元素， 每次循环将本次最大的元素移动到末尾，像是冒泡, 并且下一次循环不需要