java常用8大排序

于 2024-07-24 17:49:50 发布
阅读量996 收藏 19
点赞数 22
文章标签： java 算法 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzp1224/article/details/140669036
版权

Java中的八大排序算法是编程中常用的排序方法，每种排序算法都有其独特的特点和应用场景。以下是对Java八大排序算法的详细介绍：

1. 冒泡排序（Bubble Sort）

  • 基本思想：通过对待排序序列从前向后（或从后向前），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部（或使值较小的元素逐渐从前移向后部），就像水底的气泡一样逐渐向上冒。
  • 时间复杂度：O(n^2)
  • 空间复杂度：O(1)
  • 稳定性：稳定
public class BubbleSort {  
    public static void bubbleSort(int[] arr) {  
        int n = arr.length;  
        for (int i = 0; i < n-1; i++) {  
            for (int j = 0; j < n-i-1; j++) {  
                if (arr[j] > arr[j+1]) {  
                    // 交换 arr[j+1] 和 arr[j]  
                    int temp = arr[j];  
                    arr[j] = arr[j+1];  
                    arr[j+1] = temp;  
                }  
            }  
        }  
    }  
  
    public static void main(String[] args) {  
        int[] arr = {64, 34, 25, 12, 22, 11, 90};  
        bubbleSort(arr);  
        System.out.println("Sorted array");  
        for (int i = 0; i < arr.length; i++)  
            System.out.print(arr[i] + " ");  
        System.out.println();  
    }  
}

2. 选择排序（Selection Sort）

  • 基本思想：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。
  • 时间复杂度：O(n^2)
  • 空间复杂度：O(1)
  • 稳定性：不稳定
public class SelectionSort {  
    public static void selectionSort(int[] arr) {  
        int n = arr.length;  
        for (int i = 0; i < n-1; i++) {  
            // 找到[i, n-1]区间里的最小值的索引  
            int minIndex = i;  
            for (int j = i+1; j < n; j++) {  
                if (arr[j] < arr[minIndex]) {  
                    minIndex = j;  
                }  
            }  
            // 交换arr[i]和arr[minIndex]  
            int temp = arr[i];  
            arr[i] = arr[minIndex];  
            arr[minIndex] = temp;  
        }  
    }  
  
    public static void main(String[] args) {  
        int[] arr = {64, 25, 12, 22, 11};  
        selectionSort(arr);  
        System.out.println("Sorted array");  
        for (int i = 0; i < arr.length; i++)  
            System.out.print(arr[i] + " ");  
        System.out.println();  
    }  
}

3. 插入排序（Insertion Sort）

  • 基本思想：将一个记录插入到已经排好序的有序表中，使得被插入数的序列同样是有序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程。
  • 时间复杂度：O(n^2)（平均和最坏情况），O(n)（最好情况，即数据已经有序）
  • 空间复杂度：O(1)
  • 稳定性：稳定
public class InsertionSort {  
    public static void insertionSort(int[] arr) {  
        int n = arr.length;  
        for (int i = 1; i < n; ++i) {  
            int key = arr[i];  
            int j = i - 1;  
  
            /* 将arr[i]插入到arr[0...i-1]中已排序的序列中 */  
            while (j >= 0 && arr[j] > key) {  
                arr[j + 1] = arr[j];  
                j = j - 1;  
            }  
            arr[j + 1] = key;  
        }  
    }  
  
    public static void main(String[] args) {  
        int[] arr = {12, 11, 13, 5, 6};  
        insertionSort(arr);  
        System.out.println("Sorted array");  
        for (int i = 0; i < arr.length; i++)  
            System.out.print(arr[i] + " ");  
        System.out.println();  
    }  
}

4. 希尔排序（Shell Sort）

  • 基本思想：也称缩小增量排序，是插入排序的一种更高效的改进版本。希尔排序通过将原来要排序的数列分割成几个子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
  • 时间复杂度：取决于增量序列的选择，最好为O(nlogn)，最坏为O(n^2)
  • 空间复杂度：O(1)
  • 稳定性：不稳定
public class ShellSort {  
  
    // 希尔排序  
    public static void sort(int[] arr) {  
        int n = arr.length;  
        // 初始步长  
        for (int gap = n / 2; gap > 0; gap /= 2) {  
            // 从第gap个元素开始，逐个对其所在组进行直接插入排序操作  
            for (int i = gap; i < n; i++) {  
                int temp = arr[i];  
                int j;  
                // 对每个组进行插入排序  
                for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {  
                    arr[j] = arr[j - gap];  
                }  
                arr[j] = temp;  
            }  
        }  
    }  
  
    // 测试方法  
    public static void main(String[] args) {  
        int[] arr = {9, 8, 3, 7, 5, 6, 4, 1};  
        sort(arr);  
        System.out.println("Sorted array: ");  
        for (int i = 0; i < arr.length; i++) {  
            System.out.print(arr[i] + " ");  
        }  
    }  
}

5. 快速排序（Quick Sort）

  • 基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。
  • 时间复杂度：O(nlogn)（平均情况），O(n^2)（最坏情况，如数组已经有序）
  • 空间复杂度：O(logn)（递归栈空间）
  • 稳定性：不稳定
public class QuickSort {  
  
    // 快速排序的递归方法  
    public static void quickSort(int[] arr, int low, int high) {  
        if (low < high) {  
            // partitionIndex是分区后基准值的正确位置  
            int partitionIndex = partition(arr, low, high);  
  
            // 递归地对基准值左边的子数组进行排序  
            quickSort(arr, low, partitionIndex - 1);  
  
            // 递归地对基准值右边的子数组进行排序  
            quickSort(arr, partitionIndex + 1, high);  
        }  
    }  
  
    // 分区方法  
    private static int partition(int[] arr, int low, int high) {  
        // 选择最右边的元素作为基准值  
        int pivot = arr[high];  
        int i = (low - 1); // 小于基准值的元素的索引  
  
        for (int j = low; j < high; j++) {  
            // 如果当前元素小于或等于基准值  
            if (arr[j] <= pivot) {  
                i++;  
  
                // 交换arr[i]和arr[j]  
                int temp = arr[i];  
                arr[i] = arr[j];  
                arr[j] = temp;  
            }  
        }  
  
        // 将基准值交换到它的最终位置  
        int temp = arr[i + 1];  
        arr[i + 1] = arr[high];  
        arr[high] = temp;  
  
        return i + 1;  
    }  
  
    // 测试方法  
    public static void main(String[] args) {  
        int[] arr = {10, 7, 8, 9, 1, 5};  
        quickSort(arr, 0, arr.length - 1);  
  
        System.out.println("Sorted array: ");  
        for (int i = 0; i < arr.length; i++) {  
            System.out.print(arr[i] + " ");  
        }  
    }  
}

6. 归并排序（Merge Sort）

  • 基本思想：采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
  • 时间复杂度：O(nlogn)
  • 空间复杂度：O(n)（需要额外的数组来存储合并后的序列）
  • 稳定性：稳定
public class MergeSort {  
  
    // 归并排序的递归方法  
    public static void mergeSort(int[] arr, int left, int right) {  
        if (left < right) {  
            // 找到中间位置  
            int middle = left + (right - left) / 2;  
  
            // 对左半部分进行归并排序  
            mergeSort(arr, left, middle);  
  
            // 对右半部分进行归并排序  
            mergeSort(arr, middle + 1, right);  
  
            // 合并两个有序数组  
            merge(arr, left, middle, right);  
        }  
    }  
  
    // 合并两个有序数组的方法  
    private static void merge(int[] arr, int left, int middle, int right) {  
        // 创建临时数组来存储合并后的结果  
        int[] temp = new int[right - left + 1];  
  
        // 初始化两个指针，分别指向左右两个子数组的起始位置  
        int i = left;  
        int j = middle + 1;  
        int k = 0;  
  
        // 遍历两个子数组，将较小的元素先放入临时数组  
        while (i <= middle && j <= right) {  
            if (arr[i] <= arr[j]) {  
                temp[k++] = arr[i++];  
            } else {  
                temp[k++] = arr[j++];  
            }  
        }  
  
        // 如果左子数组还有剩余元素，将它们复制到临时数组  
        while (i <= middle) {  
            temp[k++] = arr[i++];  
        }  
  
        // 如果右子数组还有剩余元素，将它们复制到临时数组  
        while (j <= right) {  
            temp[k++] = arr[j++];  
        }  
  
        // 将临时数组中的元素复制回原数组  
        for (i = left, k = 0; i <= right; i++, k++) {  
            arr[i] = temp[k];  
        }  
    }  
  
    // 测试方法  
    public static void main(String[] args) {  
        int[] arr = {12, 11, 13, 5, 6, 7};  
        mergeSort(arr, 0, arr.length - 1);  
  
        System.out.println("Sorted array: ");  
        for (int i = 0; i < arr.length; i++) {  
            System.out.print(arr[i] + " ");  
        }  
    }  
}

7. 堆排序（Heap Sort）

  • 基本思想：是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。
  • 时间复杂度：O(nlogn)
  • 空间复杂度：O(1)（原地排序）
  • 稳定性：不稳定
public class HeapSort {  
  
    // 堆排序  
    public static void sort(int[] arr) {  
        int n = arr.length;  
  
        // 构建最大堆  
        for (int i = n / 2 - 1; i >= 0; i--) {  
            heapify(arr, n, i);  
        }  
  
        // 一个个从堆顶取出元素  
        for (int i = n - 1; i > 0; i--) {  
            // 移动当前根到末尾  
            int temp = arr[0];  
            arr[0] = arr[i];  
            arr[i] = temp;  
  
            // 调整剩余元素，使其重新成为最大堆  
            heapify(arr, i, 0);  
        }  
    }  
  
    // 调整最大堆  
    private static void heapify(int[] arr, int n, int i) {  
        int largest = i; // 初始化最大为根  
        int left = 2 * i + 1; // 左 = 2*i + 1  
        int right = 2 * i + 2; // 右 = 2*i + 2  
  
        // 如果左子节点大于根  
        if (left < n && arr[left] > arr[largest]) {  
            largest = left;  
        }  
  
        // 如果右子节点大于目前最大  
        if (right < n && arr[right] > arr[largest]) {  
            largest = right;  
        }  
  
        // 如果最大不是根  
        if (largest != i) {  
            int swap = arr[i];  
            arr[i] = arr[largest];  
            arr[largest] = swap;  
  
            // 递归地调整受影响的子树  
            heapify(arr, n, largest);  
        }  
    }  
  
    // 测试方法  
    public static void main(String[] args) {  
        int[] arr = {12, 11, 13, 5, 6, 7};  
        sort(arr);  
  
        System.out.println("Sorted array: ");  
        for (int i = 0; i < arr.length; i++) {  
            System.out.print(arr[i] + " ");  
        }  
    }  
}

8. 计数排序（Counting Sort）

  • 基本思想：不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
  • 时间复杂度：O(n+k)（k是整数的范围）
  • 空间复杂度：O(k)
  • 稳定性：稳定
public class CountingSort {  
  
    // 计数排序  
    public static void countingSort(int[] arr) {  
        if (arr == null || arr.length == 0) return;  
  
        int max = arr[0];  
        int min = arr[0];  
  
        // 找出数组中的最大值和最小值  
        for (int i = 1; i < arr.length; i++) {  
            if (arr[i] > max) max = arr[i];  
            if (arr[i] < min) min = arr[i];  
        }  
  
        // 计数数组的长度为max-min+1，用于记录每个元素的出现次数  
        int[] count = new int[max - min + 1];  
  
        // 遍历待排序数组，统计每个元素的出现次数  
        for (int i = 0; i < arr.length; i++) {  
            count[arr[i] - min]++;  
        }  
  
        // 更改count[i]，使其包含实际在arr[]中的位置信息  
        // 这一步是为了确保排序的稳定性  
        for (int i = 1; i < count.length; i++) {  
            count[i] += count[i - 1];  
        }  
  
        // 构建输出数组  
        int[] output = new int[arr.length];  
  
        // 反向填充目标数组，以保持稳定性  
        for (int i = arr.length - 1; i >= 0; i--) {  
            output[count[arr[i] - min] - 1] = arr[i];  
            count[arr[i] - min]--;  
        }  
  
        // 将排序后的数组复制到原数组  
        for (int i = 0; i < arr.length; i++) {  
            arr[i] = output[i];  
        }  
    }  
  
    // 测试方法  
    public static void main(String[] args) {  
        int[] arr = {4, 2, 2, 8, 3, 3, 1};  
        countingSort(arr);  
  
        System.out.println("Sorted array: ");  
        for (int i = 0; i < arr.length; i++) {  
            System.out.print(arr[i] + " ");  
        }  
    }  
}

这些排序算法在Java中都有广泛的应用，根据具体的数据情况和性能要求选择合适的排序算法是非常重要的。

一枚进阶码农
关注
「Java」- 八大排序
「zero」的博客
11-09 1992
冒泡排序 原理:在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序 一次排序过程
Java常用8大排序算法
08-02
除了以上介绍的四种排序算法外，Java中还有以下几种常用的排序算法： 1. **冒泡排序**：每次比较两个相邻的元素，如果它们的顺序错误就把它们交换过来。遍历所有元素之后，最大的元素就会被放到最后的位置上。然后...
java从小到大排序函数_Java8函数之旅 (五) -- Java8中的排序
weixin_30832021的博客
02-13 813
前言对数据进行排序是平常经常会用到的操作之一，使用Jav8排序可以减少你在排序这方面的代码量，优化你的代码。测试用例代码定义个实体类User，拥有姓名name,年龄age,积分credits三个属性,定义一个包含User的集合，用于排序，下面是代码/* 这里偷个懒，用lombok注解生成实体类getset等一些基本方法 */@Data@AllArgsConstructor@NoArgsConstr...
java8大排序
12-23
java8大排序
Java8 排序
01-13 637
Java8新特性，排序语法。 public class Human { private String name; private int age; public Human() { super(); } public Human(final String name, final int age) { super(); t
Java8排序
悠然星的博客
08-19 389
Java8排序stream.sorted() sorted() 默认使用自然序排序， 其中的元素必须实现Comparable 接口 sorted(Comparator<? super T> comparator) 下面代码自然排序一个list list.stream().sorted() 自然逆序元素，使用Comparator 提供的rever...
java的九种排序算法
明月清风
03-31 679
为了便于管理，先引入个基础类：public abstract class SorterE extends ComparableE>> {        public abstract void sort(E[] array,int from ,int len);        public final void sort(E[] array)    {        sort(array,0,ar
Java常用排序算法程序员必须掌握的8大排序算法
最新发布
09-13
冒泡排序--Java常用排序算法程序员必须掌握的8大排序算法
Java常用排序算法&程序员必须掌握的8大排序算法+二分法查找
08-03
本资料包聚焦于"Java常用排序算法"和"程序员必须掌握的8大排序算法"，并深入探讨了"二分法查找"这一高效搜索技术。 首先，我们来看八大排序算法。这些算法包括： 1. **冒泡排序**：最简单的排序方法，通过不断交换...
Java实现八大排序算法
09-18
Java实现八大排序算法
程序员必须掌握！Java常用的8大排序算法
02-02
Java常用的8大排序算法是程序员必备的技能之一，这些排序算法根据排序过程中是否需要使用额外的存储空间，可以分为内排序和外排序两大类。内排序指所有排序操作都在内存中完成，而外排序则涉及到将数据存放到外部...
Java 8 排序
暗武逢天的博客
03-08 3506
java排序
java8 - 排序
光与热的博客
12-20 1304
java8以前在java以前为了对集合排序,通常的做法是这样的bean如下private static class Person { private final String name; private final int age; public Person(String name, int age) { this.name = name;
【java】java8排序
凤凰涅槃
09-12 263
目录需求实现注意 需求 查询出一个list,我要按状态和创建时间排序，为什么不在数据库直接排好序呢？因为我的状态我重新赋值了，数据库中没有对应的字段，同时也不是一个SQL所能解决的业务。可以理解拼接啦 实现 // 按状态排序 List<Info> projectInfoList = InfoList.stream() .sorted(Comparator.comparing(Info::getCreated_at).reversed()) .sorted(
Java中的排序
diamond__的博客
02-17 352
1.概念 1.1排序 排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 平时的上下文中，如果提到排序，通常指的是排升序（非降序）。 通常意义上的排序，都是指的原地排序(in place sort) 1.2稳定性（重要） 两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法： 2.七大基于比较的排序 3.插入...
Java 八大排序算法
chenssy 的技术博客
04-30 5744
数据结构 + 算法 是我们编程的灵魂，其中一个都不能缺少，数据结构我们要掌握的也就那几种，算法也一样，其中排序算法是我们最常见的，也是面试、考核中最为广泛的，在 Java 的世界中我们需要掌握八大排序算法，这是我们进阶，进入大公司一定不能躲避的，所以这八种排序算法是我们必须要掌握的。 Java 排序算法 — 直接插入排序 Java 排序算法 — 希尔排序 Java 排序算法 — 简单选择排序 J...
Java基础学习总结（60）——Java常用的八种排序算法
weixin_33834628的博客
09-11 640
1.直接插入排序 经常碰到这样一类排序问题：把新的数据插入到已经排好的数据列中。 将第一个数和第二个数排序，然后构成一个有序序列将第三个数插入进去，构成一个新的有序序列。对第四个数、第五个数……直到最后一个数，重复第二步。 ![Uploading Paste_Image_937999.png . . .] 如何写写成代码： 首先设定插入次数，即循环次数，for(int i=1;i&l...
Java七大排序算法实战解析
"本文详细解析了Java中的七大常见排序方法，包括直接插入排序，并提供了具体的Java代码实例。这些方法对于理解和掌握Java排序算法具有重要意义。" 在Java编程中，排序是数据处理的一个基础操作，广泛应用于各种场景...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值