Java实现排序算法

排序算法

选择排序

直接选择排序

图解过程：

示例代码：

public class SelectSort {
    public static void main(String[] args) {
        int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        selectSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }

    public static void selectSort(int[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;
        for (int i = 0; i < arrayLength - 1; i++) {
            // i节点依次与后面的节点进行比较
            for (int j = i + 1; j < arrayLength; j++) {
                // 后面的任意节点小于i节点则交换位置
                if (data[i] - data[j] > 0) {
                    int temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                }
            }
            System.out.println(java.util.Arrays.toString(data));
        }
    }

    // 改进
    public static void selectSort1(int[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;
        for (int i = 0; i < arrayLength - 1; i++) {
            // 记录i及后面中最小节点的索引
            int minIndex = i;
            // 依次找到i及后面中最小节点的索引
            for (int j = i + 1; j < arrayLength; j++) {
                if (data[minIndex] - data[j] > 0) {
                    minIndex = j;
                }
            }
            // 最小节点的索引不是i时，交换节点i和最小节点
            if(minIndex != i){
                int temp = data[i];
                data[i] = data[minIndex];
                data[minIndex] = temp;
            }
            System.out.println(java.util.Arrays.toString(data));
        }
    }
}

堆排序

图解过程：

示例代码：

public class HeapSort {
    public static void main(String[] args) {
        int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        heapSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }

    public static void heapSort(int[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;
        // 循环建堆
        for (int i = 0; i < arrayLength - 1; i++) {
            // 建堆
            buildMaxdHeap(data, arrayLength - 1 - i);
            // 交换堆顶和最后一个元素
            swap(data, 0, arrayLength - 1 - i);
            System.out.println(java.util.Arrays.toString(data));
        }
    }

    // 对data数组从0到lastIndex建大顶堆
    private static void buildMaxdHeap(int[] data, int lastIndex) {
        // 从lastIndex处节点（最后一个节点）的父节点开始
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
            // k保存当前正在判断的节点
            int k = i;
            // 如果当前k节点的子节点存在
            while (k * 2 + 1 <= lastIndex) {
                // k节点的左子节点的索引
                int biggerIndex = 2 * k + 1;
                // 如果biggerIndex小于lastIndex，即biggerIndex +1
                // 代表k节点的右子节点存在
                if (biggerIndex < lastIndex) {
                    // 如果右子节点的值较大
                    if (data[biggerIndex] - data[biggerIndex + 1] < 0) {
                        // biggerIndex总是记录较大子节点的索引
                        biggerIndex++;
                    }
                }
                // 如果k节点的值小于其较大子节点的值
                if (data[k] - data[biggerIndex] < 0) {
                    // 交换它们
                    swap(data, k, biggerIndex);
                    // 将biggerIndex赋给k，开始while循环的下一次循环
                    // 重新保证k节点的值大于其左、右节点的值
                    k = biggerIndex;
                } else {
                    break;
                }
            }
        }
    }

    // 交换data数组中i、j两个索引处的元素
    private static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

交换排序

冒泡排序

图解过程：

示例代码：

public class BubbleSort {
    public static void main(String[] args) {
        int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        bubbleSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }

    public static void bubbleSort(int[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;
        for (int i = 0; i < arrayLength - 1; i++) {
            // 依次比较前面arrayLength-1-i个相邻元素
            for (int j = 0; j < arrayLength - 1 - i; j++) {
                // 将相邻元素中较大的元素前移（最后i元素最大）
                if (data[j] > data[j + 1]) {
                    int temp = data[j + 1];
                    data[j + 1] = data[j];
                    data[j] = temp;
                }
            }
            System.out.println(java.util.Arrays.toString(data));
        }
    }
    
    // 优化
    public static void bubbleSort1(int[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;
        for (int i = 0; i < arrayLength - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < arrayLength - 1 - i; j++) {
                if (data[j] > data[j + 1]) {
                    int temp = data[j + 1];
                    data[j + 1] = data[j];
                    data[j] = temp;
                    flag = true;    // 若没有执行，则表示前arrayLength-1-i个元素已经有序
                }
            }
            System.out.println(java.util.Arrays.toString(data));
            // 已经排序完成，结束排序
            if (!flag)
                break;
        }
    }
}

快速排序

图解过程：

示例代码：

public class QuickSort {
    public static void main(String[] args) {
        int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        quickSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }

    public static void quickSort(int[] data){
        subSort(data,0,data.length - 1);
    }

    private static void subSort(int[] data, int start, int end) {
        if (start < end) {
            int base = data[start]; // 保存第一个元素
            int low = start;
            int high = end + 1;
            while (true) {
                // 找到左边第一个大于第一个元素的元素索引low
                while (low < end && data[++low] - base <= 0)
                    ;
                // 找到右边第一个小于第一个元素的元素索引high
                while (high > start && data[--high] - base >= 0)
                    ;
                if (low < high) {
                    swap(data, low, high);  // 交换两个索引对应的元素
                } else {
                    break;
                }
            }
            swap(data, start, high);    // 交换该元素和最后一个比该元素小的元素

            subSort(data, start, high - 1); // 递归调用小于该元素部分
            subSort(data, high + 1, end);   // 递归调用大于该元素部分
        }
    }

    private static void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }
}

插入排序

直接插入排序

图解过程：

示例代码：

public class InsertSort {
    public static void main(String[] args) {
        int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        insertSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }

    public static void insertSort(int[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;
        for (int i = 1; i < arrayLength; i++) {
            int temp = data[i]; // 保存当前操作的元素
            // 该元素小于前面的元素
            if (data[i] - data[i - 1] < 0) {
                int j = i - 1;
                // 将该元素前面小于该元素的元素前移
                for (; j >= 0 && data[j] - temp > 0; j--) {
                    data[j + 1] = data[j];
                }
                data[j + 1] = temp; // 将该元素插入到最后一个大于该元素的元素前面
            }
            System.out.println(java.util.Arrays.toString(data));
        }

    }
}

折半插入排序

图解过程：

示例代码：

public class BinaryInsertSort {
    public static void main(String[] args) {
        int[] data = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        binaryInsertSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }

    public static void binaryInsertSort(int[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;
        for (int i = 1; i < arrayLength; i++) {
            int temp = data[i]; // 保存当前操作的元素
            int low = 0;    // 操作区间的第一个元素
            // 操作区间依次变大，为当前元素前面的所有元素，且前面的元素已经排好序
            int high = i - 1;   // 操作区间的最后一个元素
            while (low <= high) {
                int mid = (low + high) / 2; // 操作区间的中间元素
                // 该元素大于中间元素则该元素位于右边区间，否则位于左边区间
                if (temp > data[mid]) {
                    low = mid + 1;
                } else {
                    high = mid - 1;
                }
            }
            // 将该元素前面小于该元素的元素前移
            for (int j = i; j > low; j--) {
                data[j] = data[j - 1];
            }
            data[low] = temp;   // 将该元素插入到最后一个大于该元素的元素前面
            System.out.println(java.util.Arrays.toString(data));
        }
    }
}

希尔排序

图解过程：

示例代码：

public class ShellSort {
    public static void main(String[] args) {
//        int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
        int[] data = { 84, 83, 88, 87, 61, 50, 70, 60, 80, 99 };
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        shellSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }

    public static void shellSort(int[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;

        int h = 1;
        // 确定步长
        while (h <= arrayLength / 3) {
            h = h * 3 + 1;
        }
        while (h > 0) {
            System.out.println("===h的值：" + h + "===");
            // 步长为h之间的元素进行插入排序
            for (int i = h; i < arrayLength; i++) {
                int temp = data[i];
                if (data[i] - data[i - h] < 0) {
                    int j = i - h;
                    for (; j >= 0 && data[j] - temp > 0; j -= h) {
                        data[j + h] = data[j];
                    }
                    data[j + h] = temp;
                }
                System.out.println(java.util.Arrays.toString(data));
            }
            h = (h - 1) / 3;
        }
    }
}

归并排序

图解过程：

示例代码：

public class MergeSort {
    public static void main(String[] args) {
        int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        mergeSort(data);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }

    public static void mergeSort(int[] data) {
        // 归并排序
        sort(data, 0, data.length - 1);
    }

    // 将索引从left到right范围的数组元素进行归并排序
    private static void sort(int[] data, int left, int right) {
        if(left < right){
            // 找出中间索引
            int center = (left + right) / 2;
            sort(data,left,center); // 对左侧元素进行归并排序
            sort(data,center+1,right);  //右侧元素进行归并排序
            // 合并
            merge(data,left,center,right);
        }
    }

    // 将两个数组进行归并，归并前两个数组已经有序，归并后依然有序
    private static void merge(int[] data, int left, int center, int right) {
        int[] tempArr = new int[data.length];
        int mid = center + 1;   // 右侧数组第一个元素
        int third = left;   // tempArr数组的第一个元素
        int temp = left;    //
        // 两个数组分别向右遍历，将小的元素依次放入tempArr数组中（其中一个数组遍历结束则循环结束）
        while (left <= center && mid <= right) {
            if (data[left] - data[mid] <= 0) {
                tempArr[third++] = data[left++];
            } else {
                tempArr[third++] = data[mid++];
            }
        }
        // 将未遍历完的数组的剩余元素放入tempArr数组的尾部
        while (mid <= right) {
            tempArr[third++] = data[mid++];
        }
        while (left <= center) {
            tempArr[third++] = data[left++];
        }
        // 将tempArr数组中left到right间的元素依次复制到data数组中
        while (temp <= right) {
            data[temp] = tempArr[temp++];
        }
    }
}

桶式排序

图解过程：

示例代码：

public class BucketSort {
    public static void main(String[] args) {
        int[] data = { 9, 5, -1, 8, 5, 7, 3, -3, 1, 3 };
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        bucketSort(data, -3, 9 + 1);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }

    public static void bucketSort(int[] data, int min, int max) {
        System.out.println("开始排序");
        int arrayLength = data.length;
        int[] temp = new int[arrayLength];
        int[] buckets = new int[max - min]; // 存储max-min个桶
        // 每个桶的元素个数
        for (int i = 0; i < arrayLength; i++) {
            buckets[data[i] - min]++;
        }
        System.out.println(Arrays.toString(buckets));
        // 每个桶的元素位置
        for (int i = 1; i < max - min; i++) {
            buckets[i] = buckets[i] + buckets[i - 1];
        }
        System.out.println(Arrays.toString(buckets));
        // 当data数组的元素复制到temp数组中进行缓存
        System.arraycopy(data, 0, temp, 0, arrayLength);
        // 依次将temp数组中的元素根据桶中元素位置存储到相应索引的data数组中
        for (int k = arrayLength - 1; k >= 0; k--) {
            data[--buckets[temp[k] - min]] = temp[k];
        }
    }
}

基数排序

图解过程：

示例代码：

public class RadixSort {
    public static void main(String[] args) {
        int[] data = { 1100, 192, 221, 12, 13 };
        System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
        radixSort(data, 10, 4);
        System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
    }

    public static void radixSort(int[] data, int radix, int d) {
        System.out.println("开始排序：");
        int arrayLength = data.length;
        int[] temp = new int[arrayLength];
        int[] buckets = new int[radix];
        for (int i = 0, rate = 1; i < d; i++) {
            // 重置count数组，开始统计第二个关键字
            Arrays.fill(buckets, 0);
            // 当data数组的元素复制到temp数组中进行缓存
            System.arraycopy(data, 0, temp, 0, arrayLength);
            // 每个桶的元素个数
            for (int j = 0; j < arrayLength; j++) {
                int subKey = (temp[j] / rate) % radix;  // 桶中元素为第j+1位上的数字
                buckets[subKey]++;
            }
            // 每个桶的元素位置
            for (int j = 1; j < radix; j++) {
                buckets[j] = buckets[j] + buckets[j - 1];
            }
            // 依次将temp数组中的元素根据桶中元素位置存储到相应索引的data数组中
            for (int m = arrayLength - 1; m >= 0; m--) {
                int subKey = (temp[m] / rate) % radix;
                data[--buckets[subKey]] = temp[m];
            }
            System.out.println("对" + rate + "位上子关键字排序："
                    + java.util.Arrays.toString(data));
            rate *= radix;  // 统计的下一位关键字
        }
    }
}