Java实现排序算法

最新推荐文章于 2023-07-18 20:36:11 发布

姚舜禹_12140

最新推荐文章于 2023-07-18 20:36:11 发布

阅读量432

点赞数

分类专栏： Java 文章标签： java 排序算法算法后端数据结构

本文链接：https://blog.csdn.net/weixin_47382783/article/details/126333016

版权

Java 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

1、冒泡排序

算法思想：

以升序为例，冒泡排序的核心思想如下：

Step1：从第一个元素开始，比较相邻的两个元素，如果前一个元素的值比后一个元素的值大，那么就进行交换。
Step2：每组相邻元素，都是同样的操作，直到没有相邻元素可以比较为止，那么此时最后的元素就是最大的数。
Step3：对剩余元素重复以上步骤，直到没有任何一对元素需要比较为止。

算法代码：

    public static int[] bobbleSort(int[] arr){
        //控制外层的循环次数
        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 temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

2、选择排序

算法思想：

选择排序首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

算法代码：

    public static int[] selectSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            //标记最小下标
            int min = i;
            for (int j = i+1; j < arr.length; j++) {
                //进行比较
                if(arr[min] > arr[j]){
                    min = j;
                }
            }
            //交换
            if(i != min){
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }
        }
        return arr;
    }

3、插入排序

算法思想：

插入排序会选定一个下标，认为在这个下标之前的元素都是有序的。将下标所在的元素插入到其之前的序列中。接着再选取这个下标的后一个元素，继续重复操作。直到最后一个元素完成插入为止。一般从序列的第二个元素开始操作。

算法代码：

     public static int[] insertSort(int[] arr){
        //遍历所有数字
        for(int i=1;i<arr.length;i++) {
            //当前数字比它的前一个数字小
            if(arr[i] < arr[i - 1]) {
                int j;
                // 把当前遍历的数字保存起来
                int temp = arr[i];
                for(j = i - 1; j >= 0 && arr[j] > temp; j--) {
                    // 前一个数字赋给后一个数字
                    arr[j + 1] = arr[j];
                }
                // 把临时变量赋给不满足条件的后一个元素
                arr[j + 1] = temp;
            }
        }
        return arr;
    }

4、希尔排序

算法思想：

某些情况下直接插入排序的效率极低。比如一个已经有序的升序数组，这时再插入一个比最小值还要小的数，也就意味着被插入的数要和数组所有元素比较一次。我们需要对直接插入排序进行改进。

希尔排序把序列按下标的一定增量（步长）分组，对每组分别使用插入排序。随着增量（步长）减少，一直到一，算法结束，整个序列变为有序。因此希尔排序又称缩小增量排序。一般来说，初次取序列的一半为增量，以后每次减半，直到增量为一。

算法代码：

    public static int[] shellSort(int[] arr){
        for(int step = arr.length/2;  step > 0; step /= 2){
            for (int i = 0; i < arr.length; i++) {
                int temp = arr[i];
                int j = i - step;
                while(j >= 0 && temp < arr[j]){
                    arr[j+step] = arr[j];
                    j -= step;
                }
                arr[j+step] = temp;
            }
        }
        return arr;
    }

5、快速排序

算法思想：

快速排序将待排序的数组拆分成左右两个区间，然后选择一个基准值，基准值可以选择数组最左边、中间或者最右边的值，也可以随机选取。然后使用双指针left和right分别指向数组的起始位置和末尾位置，并与基准值进行比较，使得数组左区间的值都小于基准值，数组右区间的值都大于基准值。然后继续拆分，执行相同操作，直到每个区间只有一个数为止。举例如下：

算法代码：

    public static int[] sort(int[] arr){
        quickSort(arr, 0, arr.length-1);
        return arr;
    }
    public static void quickSort(int[] array, int start, int end){
        if(start >= end){
            return;
        }
        //以最左边节点作为参考值
        int pivot = array[start];
        //定义两个指针
        int left = start, right = end;
        while(left < right){
            //找到第一个比基准值小的值
            while(left < right && array[right] >= pivot){
                right --;
            }
            //把左边的数替换成右边的数
            array[left] = array[right];
            //找到第一个比基准值大的值
            while(left < right && array[left] <= pivot){
                left ++;
            }
            //把右边的数替换成左边的数
            array[right] = array[left];
        }
        //把标准值赋给下标重合的位置
        array[left] = pivot;
        //处理左边
        quickSort(array, start, left);
        //处理右边
        quickSort(array, left+1, end);
    }

6、归并排序

算法思想：

归并排序是建立在归并操作上的一种有效，稳定的排序算法。该算法采用分治法的思想，是一个非常典型的应用。归并排序的思路如下：

Step 1：将 n 个元素分成两个各含 n/2 个元素的子序列
Step 2：借助递归，两个子序列分别继续进行第一步操作，直到不可再分为止
Step 3：此时每一层递归都有两个子序列，再将其合并，作为一个有序的子序列返回上一层，再继续合并，全部完成之后得到的就是一个有序的序列

关键在于两个子序列应该如何合并。假设两个子序列各自都是有序的，那么合并步骤就是：

Step 1：创建一个用于存放结果的临时数组，其长度是两个子序列合并后的长度
Step 2：设定两个指针，最初位置分别为两个已经排序序列的起始位置
Step 3：比较两个指针所指向的元素，选择相对小的元素放入临时数组，并移动指针到下一位置
Step 4：重复步骤 3 直到某一指针达到序列尾
Step 5：将另一序列剩下的所有元素直接复制到合并序列尾

算法代码：

    public static int[] mergeSort(int[] arr, int low, int high){
        //获取中间值
        int mid = low + (high - low) / 2;
        if(low < high){
            //处理左边数组
            mergeSort(arr, low, mid);
            //处理右边数组
            mergeSort(arr, mid+1, high);
            merge(arr, low, mid, high);
        }
        return arr;
    }
    public static void merge(int[] arr, int low, int mid, int high){
        int[] tempArray = new int[high-low+1];
        //记录第一个数组中需要遍历的下标
        int i = low;
        //记录第二个数组中需要的遍历的下标
        int j = mid + 1;
        //记录临时数组的下标
        int index = 0;
        //遍历两个数组，进行比较，将较小的数字放入临时数组
        while(i <= mid && j <= high){
            if(arr[i] <= arr[j]){
                tempArray[index] = arr[i];
                i++;
            }else{
                tempArray[index] = arr[j];
                j++;
            }
            index ++;
        }
        //将剩余数据放入临时数组
        while(i <= mid){
            tempArray[index++] = arr[i++];
        }
        while(j <= high){
            tempArray[index++] = arr[j++];
        }
        //把临时数组中的数据放入原数组
        for (int k = 0; k < tempArray.length; k++) {
            arr[k+low] = tempArray[k];
        }
    }

7、堆排序

算法思想：

对于任何一个数组都可以看成一颗完全二叉树。堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。如下图：

像上图的大顶堆，映射为数组，就是 [50, 45, 40, 20, 25, 35, 30, 10, 15]。可以发现第一个下标的元素就是最大值，将其与末尾元素交换，则末尾元素就是最大值。所以堆排序的思想可以归纳为以下两步：

Step 1：根据初始数组构造堆
Step 2：每次交换第一个和最后一个元素，然后将除最后一个元素以外的其他元素重新调整为大顶堆

重复以上两个步骤，直到没有元素可操作，就完成排序了。

我们需要把一个普通数组转换为大顶堆，调整的起始点是最后一个非叶子结点，然后从左至右，从下至上，继续调整其他非叶子结点，直到根结点为止。

算法代码：

    public static void constructMaxHeap(int[] arr, int size, int index){
        //左子节点
        int leftNode = 2 * index + 1;
        //右子节点
        int rightNode = 2 * index + 2;
        int parent = index;
        //和父节点的两个孩子节点进行比较，找到最大的节点
        if(leftNode < size && arr[leftNode] > arr[parent]){
            parent = leftNode;
        }
        if(rightNode < size && arr[rightNode] > arr[parent]){
            parent = rightNode;
        }
        //交换位置
        if(parent != index){
            int temp = arr[index];
            arr[index] = arr[parent];
            arr[parent] = temp;
            //因为交换位置之后可能出现字数不满足大顶堆的条件，因此要对字数进行调整
            constructMaxHeap(arr, size, parent);
        }
    }
    public static int[] heapSort(int[] arr){
        //起始位置是最有一个非叶子节点，即最后一个节点的父节点
        int start = (arr.length-1) / 2;
        //调整为最大堆
        for (int i = start; i >= 0; i--) {
            constructMaxHeap(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;
            constructMaxHeap(arr, i, 0);
        }
        return arr;
    }

8、基数排序

算法思想：

基数排序的原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。为此需要将所有待比较的数值统一为同样的数位长度，数位不足的数在高位补零。

算法代码：

/**
 * 基数排序
 */
public static void radixSort(int[] arr) {
    // 存放数组中的最大数字
    int max = Integer.MIN_VALUE;
    for (int value : arr) {
        if (value > max) {
            max = value;
        }
    }
    // 计算最大数字是几位数
    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 remainder = arr[j] / n % 10;
            // 把当前遍历的数据放到指定的数组中
            temp[remainder][counts[remainder]] = arr[j];
            // 记录数量
            counts[remainder]++;
        }
        // 记录取的元素需要放的位置
        int index = 0;
        // 把数字取出来
        for (int k = 0; k < counts.length; k++) {
            // 记录数量的数组中当前余数记录的数量不为 0
            if (counts[k] != 0) {
                // 循环取出元素
                for (int l = 0; l < counts[k]; l++) {
                    arr[index] = temp[k][l];
                    // 记录下一个位置
                    index++;
                }
                // 把数量置空
                counts[k] = 0;
            }
        }
    }
}

9、算法总结

排序法	最好情形	平均时间	最差情形	稳定度	空间复杂度
冒泡排序	O(n)	O(n^2)	O(n^2)	稳定	O(1)
快速排序	O(nlogn)	O(nlogn)	O(n^2)	不稳定	O(nlogn)
直接插入排序	O(n)	O(n^2)	O(n^2)	稳定	O(1)
希尔排序	O(n)	O(nlogn)	O(nlogn)	不稳定	O(1)
直接选择排序	O(n^2)	O(n^2)	O(n^2)	不稳定	O(1)
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	不稳定	O(nlogn)
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	稳定	O(n)