Java基础之【排序算法】

/**
 * 生成数据，指定大小
 */
public static int[] getData(int size) {
    if (size <= 0) {
        // 默认10个元素
        size = 10;
    }
    int[] result = new int[size];
    // 随机生成[0,1000)范围的数据放入数组中
    Random random = new Random();
    for (int i = 0; i < size; i++) {
        result[i] = random.nextInt(1000);
    }
    return result;
}

交换数组中两个位置上的元素

java 复制代码

/**
 * 交换数组中两索引位置的值
 */
public static void swap(int[] data, int i, int j) {
    // 前置校验
    if (data == null || data.length < 2)
        return;
    if (i < 0 || j < 0)
        return;
    if (i == j)
        return;
    // 实现交换的逻辑
    data[i] = data[i] ^ data[j];
    data[j] = data[i] ^ data[j];
    data[i] = data[i] ^ data[j];
}

打印数组中的所有元素

java 复制代码

/**
 * 打印元素
 */
public static void printData(int[] data) {
    System.out.println(Arrays.toString(data));
}

冒泡排序

思路

相邻两个元素进行比较，比较一轮之后，最右边为最大值或者最小值
若一共有 n 个元素进行排序，则需要比较 n-1 轮，将所有元素实现排序

具体实现

java 复制代码

import java.util.Arrays;
import java.util.Random;

public class App {
    // ------------定义排序方式------------
    // 升序
    private static final int SORT_TYPE_UP = 1;
    // 降序
    private static final int SORT_TYPE_DOWN = -1;
    // ----------------------------------

    public static void main(String[] args) {
        // 需要排序的数组
        int[] data = getData(20);
        // 打印排序前的数组元素
        printData(data);
        // 调用冒泡排序算法将其进行升序排列
        bubbleSort(data, SORT_TYPE_UP);
        // 打印升序后的数组元素
        printData(data);
        // 调用冒泡排序算法将其进行降序排列
        bubbleSort(data, SORT_TYPE_DOWN);
        // 打印降序后的数组元素
        printData(data);
    }

    /**
     * 实现冒泡排序
     */
    private static void bubbleSort(int[] data, int sortType) {
        // 前置校验
        if (data == null) return;
        int size = data.length;
        if (size < 2) return;
        // 比较size-1轮
        for (int i = 0; i < size - 1; i++) {
            // 每一轮比较
            for (int j = 0; j < size - 1 - i; j++) {
                // 若当前元素大于其后一个元素，则交换元素
                if (SORT_TYPE_UP == sortType ? data[j] > data[j + 1] : data[j] < data[j + 1]) {
                    swap(data, j, j + 1);
                }
            }
        }
    }
}

选择排序

思路

从 0 索引开始，将其和之后的每个元素进行比较
根据排序方式，将大的或者小的放前面

具体实现

java 复制代码

import java.util.Arrays;
import java.util.Random;

public class App {
    // ------------定义排序方式------------
    // 升序
    private static final int SORT_TYPE_UP = 1;
    // 降序
    private static final int SORT_TYPE_DOWN = -1;
    // ----------------------------------

    public static void main(String[] args) {
        // 需要排序的数组
        int[] data = getData(20);
        // 打印排序前的数组元素
        printData(data);
        // 调用选择排序算法将其进行升序排列
        selectSort(data, SORT_TYPE_UP);
        // 打印升序后的数组元素
        printData(data);
        // 调用选择排序算法将其进行降序排列
        selectSort(data, SORT_TYPE_DOWN);
        // 打印降序后的数组元素
        printData(data);
    }

    /**
     * 实现选择排序
     */
    private static void selectSort(int[] data, int sortType) {
        // 前置校验
        if (data == null) return;
        int size = data.length;
        if (size < 2) return;
        for (int i = 0; i < size; i++) {
            for (int j = i + 1; j < size; j++) {
                if (SORT_TYPE_UP == sortType ? data[i] > data[j] : data[i] < data[j]) {
                    swap(data, i, j);
                }
            }
        }
    }
}

插入排序

思路

将数据看作是分为有序和无序两组
遍历无序那一组数据，分别将其插入到有序那一组数据中

具体实现

java 复制代码

import java.util.Arrays;
import java.util.Random;

public class App {
    // ------------定义排序方式------------
    // 升序
    private static final int SORT_TYPE_UP = 1;
    // 降序
    private static final int SORT_TYPE_DOWN = -1;
    // ----------------------------------

    public static void main(String[] args) {
        // 需要排序的数组
        int[] data = getData(20);
        // 打印排序前的数组元素
        printData(data);
        // 调用插入排序算法将其进行升序排列
        insertSort(data, SORT_TYPE_UP);
        // 打印升序后的数组元素
        printData(data);
        // 调用插入排序算法将其进行降序排列
        insertSort(data, SORT_TYPE_DOWN);
        // 打印降序后的数组元素
        printData(data);
    }

    /**
     * 实现插入排序
     */
    private static void insertSort(int[] data, int sortType) {
        // 前置校验
        if (data == null) return;
        int size = data.length;
        if (size < 2) return;
        // 默认有序的那一组数据为0索引元素，从1索引到最后都为无序的那一组
        for (int i = 0; i < size - 1; i++) {
            // j记录的是无序那组元素的开始下标，从这里的开始下标依次向前比较，将其放入有序那组合适位置上
            for (int j = i + 1; j > 0 && (SORT_TYPE_UP == sortType ? data[j - 1] > data[j] : data[j - 1] < data[j]); j--) {
                swap(data, j - 1, j);
            }
        }
    }
}

快速排序

思路

将索引 0 位置的元素看作基准数
基准数归位

具体实现

java 复制代码

import java.util.Arrays;
import java.util.Random;

public class App {
    // ------------定义排序方式------------
    // 升序
    private static final int SORT_TYPE_UP = 1;
    // 降序
    private static final int SORT_TYPE_DOWN = -1;
    // ----------------------------------

    public static void main(String[] args) {
        // 需要排序的数组
        int[] data = getData(20);
        // 打印排序前的数组元素
        printData(data);
        // 调用快速排序算法将其进行升序排列
        quickSort(data, 0, data.length - 1, SORT_TYPE_UP);
        // 打印升序后的数组元素
        printData(data);
        // 调用快速排序算法将其进行降序排列
        quickSort(data, 0, data.length - 1, SORT_TYPE_DOWN);
        // 打印降序后的数组元素
        printData(data);
    }

    /**
     * 实现快速排序
     */
    private static void quickSort(int[] data, int low, int high, int sortType) {
        // 参数校验
        if (data == null || data.length < 2)
            return;
        if (low >= high)
            return;
        // 定义基准数
        int base = data[low];
        // 定义双指针
        int start = low;
        int end = high;
        // 只要start不等于end指针
        while (start < end) {
            // 只要end指针指向的元素比基准数大(具体要看排序方式)，就往前移动该指针
            while (start < end && (SORT_TYPE_UP == sortType ? data[end] >= base : data[end] <= base))
                end--;
            // 只要start指针指向的元素比基准数小(具体要看排序方式)，就往后移动该指针
            while (start < end && (SORT_TYPE_UP == sortType ? data[start] <= base : data[start] >= base))
                start++;
            // 交换两位置的值
            swap(data, start, end);
        }
        // 到这里，start等于end
        // 交换基准数和start指针指向的值
        swap(data, low, start);
        // 递归缩小范围
        quickSort(data, low, start - 1, sortType);
        quickSort(data, start + 1, high, sortType);
    }
}

归并排序

思路

分-治-合思想的体现
每次找到中间位置，使开始到中间范围有序，使中间到结束范围有序
不断缩小范围，使得最终所有的元素有序

具体实现

java 复制代码

import java.util.Arrays;
import java.util.Random;

public class App {
    // ------------定义排序方式------------
    // 升序
    private static final int SORT_TYPE_UP = 1;
    // 降序
    private static final int SORT_TYPE_DOWN = -1;
    // ----------------------------------

    public static void main(String[] args) {
        // 需要排序的数组
        int[] data = getData(20);
        // 打印排序前的数组元素
        printData(data);
        // 调用归并排序算法将其进行升序排列
        mergeSort(data, 0, data.length - 1, SORT_TYPE_UP);
        // 打印升序后的数组元素
        printData(data);
        // 调用归并排序算法将其进行降序排列
        mergeSort(data, 0, data.length - 1, SORT_TYPE_DOWN);
        // 打印降序后的数组元素
        printData(data);
    }

    /**
     * 实现归并排序
     */
    private static void mergeSort(int[] data, int low, int high, int sortType) {
        // 参数校验
        if (data == null || data.length < 2)
            return;
        if (low >= high)
            return;
        // 中间索引
        int mid = (low + high) >>> 1;
        // 前半部分
        mergeSort(data, low, mid, sortType);
        // 后半部分
        mergeSort(data, mid + 1, high, sortType);
        // 使其有序
        merge(data, low, mid, high, sortType);
    }

    private static void merge(int[] data, int low, int mid, int high, int sortType) {
        // 协助数组
        int[] help = new int[high - low + 1];
        // 定义一个辅助变量
        int i = 0;
        // 定义双指针
        int p1 = low;
        int p2 = mid + 1;
        // 慢指针不超过mid，快指针不超过high
        if (SORT_TYPE_UP == sortType) {
            while (p1 <= mid && p2 <= high)
                help[i++] = data[p1] < data[p2] ? data[p1++] : data[p2++];
        } else {
            while (p1 <= mid && p2 <= high)
                help[i++] = data[p1] > data[p2] ? data[p1++] : data[p2++];
        }
        // 处理剩余数据
        while (p1 <= mid)
            help[i++] = data[p1++];
        while (p2 <= high)
            help[i++] = data[p2++];
        // 将结果有序
        for (i = 0; i < help.length; i++)
            data[low + i] = help[i];
    }
}