【排序算法】Java实现几种常用的排序算法

闲来无事,写了一下几种常用的排序算法,自测ok,如有测试NG的用例,欢迎指出来以便改正。

/**
 * 排序接口
 */
public interface ArraySortInterface {
    /**
     * 数组排序
     *
     * @param array 待排序数组
     */
    void sort(int[] array);
}

1.选择排序

import java.util.Arrays;

/**
 * 选择排序原理
 * 寻找数组中最小的元素,将它和数组中第0个元素交换位置
 * 在数组剩余元素中寻找最小的元素(何为剩余?现在第0个元素是最小的,从下标1开始),将它与数组的第1个元素交换位置
 * ...
 * ...
 * ...
 * 继续在数组中寻找最小的元素,将它与数组的第n个元素交换位置,如此反复,直到全部完成
 * 选择排序核心:不断寻找剩余元素中最小的元素
 */
public class SelectSort implements ArraySortInterface {
    private static final String TAG = "SelectSort";

    @Override
    public void sort(int[] array) {
        if (array == null || array.length == 0) {
            return;
        }
        System.out.println(TAG);
        sort(array, 0);
    }

    private void sort(int[] array, int start) {
        int min = array[start]; // 最小值
        int index = start; // 最小值的索引
        for (int i = start + 1; i < array.length; i++) {
            if (min > array[i]) {
                min = array[i];
                index = i;
            }
        }
        int current = array[start];
        array[start] = min;
        array[index] = current;
        start++;
        if (start < array.length) {
            sort(array, start);
        } else {
            System.out.println("here is sort result:" + Arrays.toString(array));
        }
    }
}

2.插入排序

import java.util.Arrays;

/**
 * 插入排序原理,打扑克牌的时候,我们一张接一张地抓牌
 * 1.抓到第1张牌时,无需特殊处理,放在手上
 * 2.抓第2张牌,如果比第1张牌小,放在左边;如果比第1张牌大或者一样大,放在右边(目前只有2张牌,不是左边就是右边)
 * 3.抓第3张牌,如果比第1张牌小,放在左边;如果比第2张牌大或者一样大,放在右边;如果比第1张大并且比第2张小,放在中间
 * 4.抓第4张牌,如果比第一张牌小,放在左边;如果比第3张牌大或者一样大,放在右边;如果比第1张大并且比第3张小,放在中间,这个时候手上已经有三张牌了,中间有2个位置,需要计算放到哪个位置。
 * ...
 * ...
 * ...
 * 如此反复,直到所有的牌抓完,以下为代码实现.
 */
public class InsertSort implements ArraySortInterface {
    private static final String TAG = "InsertSort";

    @Override
    public void sort(int[] array) {
        if (array == null || array.length == 0) {
            return;
        }
        System.out.println(TAG);
        for (int i = 1; i < array.length; i++) {
            // 待插入的元素,第0个无需插入
            int toBeInsert = array[i];
            if (toBeInsert >= array[i - 1]) { // 插入位置:右边
                System.out.println("the element to be insert is bigger than it's last,no need to handle");
                continue;
            }
            if (toBeInsert < array[0]) { // 插入位置:左边,即index为0的情况
                System.out.println("the element to be insert is smaller than the first element,insert to the left");
                insert(array, i, toBeInsert, 0);
                continue;
            }
            // 插入位置:[1,i-2]闭区间,计算插入位置index
            System.out.println("insert to the middle");
            int index = getInsertIndex(array, i, toBeInsert);
            insert(array, i, toBeInsert, index);
        }
        System.out.println("here is sort result:" + Arrays.toString(array));
    }

    private int getInsertIndex(int[] array, int i, int toBeInsert) {
        int index = 1; // 走到这里插入的位置不会小于1
        for (int k = 0; k < i; k++) {
            if (toBeInsert >= array[k] && toBeInsert < array[k + 1]) {
                index = k + 1;
                break;
            }
        }
        return index;
    }

    private void insert(int[] array, int i, int toBeInsert, int index) {
        for (int k = i - index - 1; k >= 0; k--) {
            array[k + index + 1] = array[k + index];
        }
        array[index] = toBeInsert;
    }
}

3.冒泡排序

import java.util.Arrays;

/**
 * 冒泡排序
 */
public class BubbleSort implements ArraySortInterface {
    private static final String TAG = "BubbleSort";

    @Override
    public void sort(int[] array) {
        if (array == null || array.length == 0) {
            return;
        }
        System.out.println(TAG);
        for (int i = 1; i < array.length; i++) {
            for (int j = 0; j < array.length - i; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j);
                }
            }
        }
        System.out.println("here is sort result:" + Arrays.toString(array));
    }

    private void swap(int[] array, int index) {
        int temp = array[index];
        array[index] = array[index + 1];
        array[index + 1] = temp;
    }
}