几大排序之java实现-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_43840954/article/details/93542605

博客主要展示了用Java实现的多种排序算法，包括冒泡排序、插入排序、归并排序、快速排序等，还提及后续会总结这些排序算法的原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

话不多说，代码先贴上

冒泡排序

package com.sun.sort;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[]{2, 5, 8, 6, 1, 9, -2, -6};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void bubbleSort(int[] arr) {
        boolean flag = true;
        for (int i = 0; i < arr.length - 1; i++) {

            for (int j = 0; j < arr.length - 1 - i; j++) {

                if (arr[j] > arr[j + 1]) {

                    int t;
                    t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }

            if (!flag) {
                break;
            }
        }
    }
}

插入排序

package com.sun.sort;

import java.util.Arrays;

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = new int[]{2, 54, 8, 6, 1, 9, -2, -6};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {

                if (arr[j] < arr[j - 1]) {
                    int t;
                    t = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = t;
                }
            }
        }
    }
}

归并排序

package com.sun.sort;

import java.util.Arrays;

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {2, 5, 8, 6, 1, 9, -2, -6};
        mergeSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));

    }

    private static void mergeSort(int[] arr, int low, int high) {
        int middle = (low + high) / 2;
        if (low < high) {
            //排左边数组
            mergeSort(arr, low, middle);
            //排右边数组
            mergeSort(arr, middle + 1, high);
            //合并数组
            merge(arr, low, middle, high);
        }
    }

    //对数组归并
    private static void merge(int[] arr, int low, int middle, int high) {
        //用于存储归并后的临时数组
        int[] temp = new int[high - low + 1];
        //第一个数组起始下标
        int i = low;
        //第二个数组起始下标
        int j = middle + 1;
        //临时数组下标
        int index = 0;

        while (i <= middle && j <= high) {
            if (arr[i] < arr[j]) {
                temp[index++] = arr[i++];
            } else {
                temp[index++] = arr[j++];
            }

        }

        //其中有一个数组较长情况下
        while(j<=high) temp[index++] = arr[j++];
        while(i<=middle) temp[index++] = arr[i++];
        
        //放入原数组
        for (int k = 0; k < temp.length; k++) {
            arr[k + low] = temp[k];
        }

    }
}

快速排序一

package com.sun.sort;

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {

        int[] arr = new int[]{3, 4, 6, 7, 2, 7, 2, 8, 0};
        quicksort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    private static void quicksort(int[] arr, int start, int end) {
        if (start < end) {
            //制定数组的起始标准数，这里为0
            int stard = arr[start];
            //记录需要排序的下标
            int low = start;
            int high = end;
            //循环找比标准数大的数和比标准数小的数
            while (low < high) {
                //右边的数比标准数大
                while (low < high && stard <= arr[high]) {
                    high--;
                }
                //使用右边的数替换左边的数
                arr[low] = arr[high];
                //左边的数比标准数小
                while (low < high && arr[low] <= stard) {
                    low++;
                }
                arr[high] = arr[low];
            }

            //低位和高位重合时，两数相等，把标准数赋给低位
            arr[low] = stard;

            //处理所有小的数据
            quicksort(arr, start, low);
            //处理所有大的数据
            quicksort(arr, low + 1, end);
        }
    }

}

快速排序二

package com.sun.sort;

import java.util.Arrays;

public class QuickSort2 {
    public static void main(String[] args) {
        int[] arr = new int[]{3, 4, 6, -7, 2, 7, -2, 8, 0};
        quicksort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    private static void quicksort(int[] arr, int low, int high) {
        if (low >= high) {
            return;
        }

        int i = low;
        int j = high;
        int key = arr[i];

        while (i < j) {

            while (i < j && key < arr[j]) {
                j--;
            }
            int t;
            if (i < j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }

            while (i < j && arr[i] < key) {
                i++;
            }

            if (i < j) {
                t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }

            quicksort(arr, low, i - 1);
            quicksort(arr, i + 1, high);

        }
    }
}

基数排列


    package com.sun.sort;

import java.util.Arrays;

public class RadixSort {
    public static void main(String[] args) {
        //基数排序
        int[] arr = new int[]{23, 6, 189, 45, 9, 287, 56, 1, 34, 65, 693, 5};
        radixSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void radixSort(int[] arr) {
        //数组中最大数
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        //计算最大数字是几位数字
        int maxLength = (max + "").length();

        //用于临时存储数据的数组
        int[][] temp = new int[10][arr.length];
        //用于记录在temp中相应的数组中存放的数字的数量
        int[] counts = new int[10];

        //根据最大长度的数决定比较的次数
        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            //把每一个数字分别计算余数
            for (int j = 0; j < arr.length; j++) {
                //计算余数
                int ys = arr[j] / n % 10;

                //把当前遍历的数据放入指定的数组中
                temp[ys][counts[ys]] = arr[j];
                //记录数量
                counts[ys]++;
            }

            /*if (i == 0) {
                for (int[] ints : temp) {
                    System.out.println(Arrays.toString(ints));
                }
            }*/

            //记录取的元素需要放的位置
            int index = 0;

            //把数字取出来
            for (int k = 0; k < counts.length; k++) {
                //记录数量的数组中当前余数记录的数量不为零
                if (counts[k] != 0) {
                    //循环取出元素
                    for (int l = 0; l < counts[k]; l++) {
                        //取出元素
                        arr[index] = temp[k][l];
                        index++;
                    }
                    //把数量置为零
                    counts[k] = 0;
                }
            }
        }
    }
}

基数排列之队列实现

package com.sun.sort;

import com.sun.queue.myQueue;

import java.util.Arrays;

public class RadixQueueSort {
    public static void main(String[] args) {
        //基数排序之队列实现
        int[] arr = new int[]{23, 6, 189, 45, 9, 287, 56, 1, 34, 65, 693, 5};
        radixSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void radixSort(int[] arr) {
        //数组中最大数
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        //计算最大数字是几位数字
        int maxLength = (max + "").length();

        //用于临时存储数据的数组
        //int[][] temp = new int[10][arr.length];

        //用于临时存储数据的队列
        myQueue[] temp = new myQueue[10];

        //为队列数组赋值
        for (int i = 0; i < temp.length; i++) {
            temp[i] = new myQueue();
        }

        //用于记录在temp中相应的数组中存放的数字的数量
        //int[] counts = new int[10];

        //根据最大长度的数决定比较的次数
        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            //把每一个数字分别计算余数
            for (int j = 0; j < arr.length; j++) {
                //计算余数
                int ys = arr[j] / n % 10;

                //把当前遍历的数据放入指定的数组中
                //temp[ys][counts[ys]] = arr[j];

                //把当前遍历的数据放入指定的队列中
                temp[ys].add(arr[j]);

                //记录数量 -----队列实现，不要记录数量
                //counts[ys]++;
            }

            //记录取的元素需要放的位置
            int index = 0;
            /*//把数字取出来
            for (int k = 0; k < counts.length; k++) {
                //记录数量的数组中当前余数记录的数量不为零
                if (counts[k] != 0) {
                    //循环取出元素
                    for (int l = 0; l < counts[k]; l++) {
                        //取出元素
                        arr[index] = temp[k][l];
                        index++;
                    }
                    //把数量置为零
                    counts[k] = 0;
                }
            }*/

            //把所有队列中的数字取出来
            for (int k = 0; k < temp.length; k++) {
                //循环取出元素
                while (!temp[k].isEmpty()) {
                    //取出元素
                    arr[index] = temp[k].poll();
                    //记录下一个位置
                    index++;
                }

            }
        }
    }
}

选择排序

package com.sun.sort;

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = new int[]{8, 2, 5, 1, -9};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));

    }

    private static void selectSort(int[] arr) {

        for (int i = 0; i <= arr.length - 2; i++) {
            int minIndex=i;
            for (int j = (i+1); j <=arr.length-1 ; j++) {
                if (arr[minIndex] > arr[j]) {
                    minIndex = j;
                }
            }

            if (minIndex != i) {
                int temp;
                temp = arr[minIndex];
                arr[minIndex]=arr[i];
                arr[i] = temp;
            }
        }
    }
}

希尔排序

package com.sun.sort;

import java.util.Arrays;

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = new int[]{2,5, 8, 6, 1, 9, -2, -6};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));

    }

    private static void shellSort(int[] arr) {
        //d 为步长
        for (int d = arr.length / 2; d > 0; d /= 2) {
            for (int i = d; i < arr.length; i++) {
                for (int j = i - d; j >= 0; j -= d) {
                    if (arr[j] > arr[j + d]) {

                        int temp = arr[j];
                        arr[j] = arr[j + d];
                        arr[j + d] = temp;
                    }
                }
            }
        }
    }
}

堆排序

package com.sun.tree.heapSort;

import java.util.Arrays;

public class HeapSort {
    public static void main(String[] args) {
        int[] arr = new int[]{9, 6, 8, 7, 0, 1, 10, 4, 2};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));

    }

    public static void heapSort(int[] arr) {
        //开始位置是最后一个非叶子节点，即最后一个节点的父节点
        //int start = (arr.length - 1) / 2; 错误的算法
        int start = arr.length / 2-1;
        //调整为大顶堆
        for (int i = start; i >= 0; i--) {
            maxHeap(arr, arr.length, i);
        }

        //先把数组中的第0个数字和堆中的最后一个数字交换位置，再把前面的数字处理成大顶堆
        for (int i = arr.length - 1; i > 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            maxHeap(arr, i, 0);
        }
    }

    public static void maxHeap(int[] arr, int size, int index) {
        //左子节点
        int leftNode = 2 * index + 1;

        //右子节点
        int rightNode = 2 * index + 2;
        int max = index;
        //和两个子节点分别对比，找出最大的节点
        if (leftNode<size && arr[leftNode] > arr[max]) {
            max = leftNode;
        }
        if (rightNode<size && arr[rightNode] > arr[max]) {
            max = rightNode;
        }
        //交换位置
        if (max != index) {
            int temp = arr[index];
            arr[index] = arr[max];
            arr[max] = temp;
            //交换位置以后，可能会破坏之前排好的堆，所以之前排好的堆需要重新调整
            maxHeap(arr, size, max);
        }
    }
}

后面再总结原理