算法基础（Java）--八大排序算法

最新推荐文章于 2023-12-16 17:17:40 发布
最新推荐文章于 2023-12-16 17:17:40 发布
阅读量378 收藏 6
点赞数
分类专栏： Java 算法 排序 文章标签： 算法 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chachapaofan/article/details/98956121
版权
Java 同时被 3 个专栏收录
22 篇文章 2 订阅
订阅专栏
算法
8 篇文章 7 订阅
订阅专栏
排序
2 篇文章 0 订阅
订阅专栏

前言

为了巩固自己的算法能力，重学算法，一个一个自己写，敲。本文主要介绍Java八大排序经典算法。

1. 冒泡排序(BubbleSort)

1.1 基本思想

两个数比较大小，较大的数下沉，较小的数冒起来。

1.2 过程

BubbleSort

1.3 算法实现

    /**
     * @Description: 冒泡排序，优化版 平均时间复杂度：O(n^2)
     * @Date: 21:11 2019/8/7
     * @Param: [arr]
     * @return: int[]
     */
    static int[] BubbleSort(int[] arr) {
        boolean flag = false;
        for (int j = 1; j < arr.length; j++) {

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

            }
            if (!flag) {
                break;
            }
        }

        return arr;
    }

2. 选择排序(SelctionSort)

2.1 基本思想

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

2.2 过程

SelctionSort

2.3 算法实现

    /**
     * @Description: 选择排序 平均时间复杂度：O(n^2)
     * @Date:        21:31 2019/8/7
     * @Param:       [arr]
     * @return:      int[]
     */
    static int[] SelctionSort(int[] arr){
        for (int i=0;i<arr.length-2;i++){
            for (int j = i+1;j<arr.length-1;j++){
                if (arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

3. 插入排序(Insertion Sort)

3.1 基本思想

在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。
如果数据序列基本有序，使用插入排序会更加高效。

3.2 过程

Insertion Sort

类似于打牌：

3.3 算法实现

    /**
     * @Description: 插入排序 平均时间复杂度：O(n^2)
     * @Date:        10:36 2019/8/8
     * @Param:       [arr]
     * @return:      int[]
     */
    static int[] insert_sort(int[] arr){
        for (int n = 1;n<arr.length;n++){
            for (int m =n;n>0;n--){
                if (arr[m]<arr[m-1]){
                    int temp = arr[m];
                    arr[m] = arr[m-1];
                    arr[m-1] = temp;
                }else {
                    break;
                }
            }
        }
        return arr;
    }

4. 希尔排序(Shell Sort)

4.1 基本思想

该方法实质上是一种分组插入方法

希尔排序属于插入类排序,是将整个有序序列分割成若干小的子序列分别进行插入排序。

在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序。然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。

4.2 过程

希尔排序在数组中采用跳跃式分组的策略，通过某个增量将数组元素划分为若干组，然后分组进行插入排序，随后逐步缩小增量，继续按组进行插入排序操作，直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序，小的基本在前，大的基本在后。然后缩小增量，到增量为1时，其实多数情况下只需微调即可，不会涉及过多的数据移动。

Shell Sort

4.3 算法实现

    /**
     * @Description: 希尔排序 平均时间复杂度O(n^1.5)
     * @Date:        11:53 2019/8/8
     * @Param:       [arr]
     * @return:      int[]
     */
    static int[] shell_sort(int[] arr) {
        int gap = arr.length;
        while (true) {
            gap = gap / 2;

            for (int k = 0; k < gap; k++) { //划分序列
                for (int n = k + gap; n < arr.length; n += gap) {
                    for (int m = n; m < k; m -= gap) {
                        if (arr[m] < arr[m - gap]) {
                            int temp = arr[m];
                            arr[m] = arr[m - gap];
                            arr[m - gap] = temp;
                        } else {
                            break;
                        }
                    }
                }
            }
            if (gap == 1) {
                break;
            }
        }
        return arr;
    }

5. 快速排序(Quicksort)

5.1 基本思想

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

5.2 过程

Quicksort

5.3 算法实现

    /**
     * @Description: 快速排序 平均时间复杂度：O(N*logN)
     * @Date: 14:13 2019/8/8
     * @Param: [arr]
     * @return: int[]
     */
    static int[] quickSort(int a[], int l, int r) {
        if (l >= r) {
            return a;
        }
        int i = l;
        int j = r;
        int key = a[l];//选择第一个数为key

        while (i < j) {
            while (i < j && a[j] >= key)//从右向左找第一个小于key的值
                j--;
            if (i < j) {
                a[i] = a[j];
                i++;
            }

            while (i < j && a[i] < key)//从左向右找第一个大于key的值
                i++;

            if (i < j) {
                a[j] = a[i];
                j--;
            }
        }
        //i == j
        a[i] = key;
        quickSort(a, l, i - 1);//递归调用
        quickSort(a, i + 1, r);//递归调用
        return a;
    }

6. 归并排序(Merge Sort)

6.1 基本思想

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。
首先将数组分为两组A，B，再将A，B组各自再分成2组。依次类推，当分出来的小组只有1个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的2个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

6.2 过程

Merge Sort

6.3 算法实现

    /**
     * @Description: 合并数列 时间复杂度O(n) 用于归并排序
     * @Date: 9:23 2019/8/9
     * @Param: [a, b]
     * @return: int[]
     */
    private static int[] mergeArray(int[] arrays, int L, int M, int R) {

        //左边的数组的大小
        int[] leftArray = new int[M - L];

        //右边的数组大小
        int[] rightArray = new int[R - M + 1];

        //往这两个数组填充数据
        if (M - L >= 0) System.arraycopy(arrays, L, leftArray, 0, M - L);
        if (R + 1 - M >= 0) System.arraycopy(arrays, M, rightArray, 0, R + 1 - M);

        int i = 0, j = 0;
        // arrays数组的第一个元素
        int k = L;


        //比较这两个数组的值，哪个小，就往数组上放
        while (i < leftArray.length && j < rightArray.length) {

            //谁比较小，谁将元素放入大数组中,移动指针，继续比较下一个
            // 等于的情况是保证“稳定”
            if (leftArray[i] <= rightArray[j]) {
                arrays[k++] = leftArray[i++];

                //相当于：
//                arrays[k] = leftArray[i];
//                i++;
//                k++;
            } else {
                arrays[k++] = rightArray[j++];
            }
        }

        //如果左边的数组还没比较完，右边的数都已经完了，那么将左边的数抄到大数组中(剩下的都是大数字)
        while (i < leftArray.length) {
            arrays[k++] = leftArray[i++];
        }
        //如果右边的数组还没比较完，左边的数都已经完了，那么将右边的数抄到大数组中(剩下的都是大数字)
        while (j < rightArray.length) {
            arrays[k++] = rightArray[j++];
        }
        return arrays;
    }

    /**
     * @Description: 归并排序 平均时间复杂度：O(N*logN)
     * @Date: 11:08 2019/8/9
     * @Param: [arrays, L, R]
     * @return: int[]
     */
    static int[] merge_sort(int[] arrays, int L, int R) {

        //如果只有一个元素，那就不用排序了
        if (L == R) {
            return arrays;
        } else {

            //取中间的数，进行拆分
            int M = (L + R) / 2;

            //左边的数不断进行拆分
            merge_sort(arrays, L, M);

            //右边的数不断进行拆分
            merge_sort(arrays, M + 1, R);

            //合并
            return mergeArray(arrays, L, M + 1, R);
        }
    }

要想深入了解归并排序的小伙伴，可以参考：归并排序及优化(Java实现)

7. 堆排序(HeapSort)

7.1 基本思想

将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根节点。将它移走(其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次最大值。如此反复执行，就能得到一个有序序列了。

7.2 过程

HeapSort

（88,85,83,73,72,60,57,48,42,6）

7.3 算法实现

    /**
     * @Description: 堆排序 平均时间复杂度：O(N*logN)
     * @Date: 12:00 2019/8/9
     * @Param: [arr]
     * @return: int[]
     */
    static int[] heapSort(int[] arr) {
        // 将待排序的序列构建成一个大顶堆
        for (int i = arr.length / 2; i >= 0; i--) {
            heapAdjust(arr, i, arr.length);
        }

        // 逐步将每个最大值的根节点与末尾元素交换，并且再调整二叉树，使其成为大顶堆
        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, 0, i); // 将堆顶记录和当前未经排序子序列的最后一个记录交换
            heapAdjust(arr, 0, i); // 交换之后，需要重新检查堆是否符合大顶堆，不符合则要调整
        }
        return arr;
    }

    /**
     * 构建堆的过程
     *
     * @param arr 需要排序的数组
     * @param i   需要构建堆的根节点的序号
     * @param n   数组的长度
     */
    private static void heapAdjust(int[] arr, int i, int n) {
        int child;
        int father;
        for (father = arr[i]; leftChild(i) < n; i = child) {
            child = leftChild(i);

            // 如果左子树小于右子树，则需要比较右子树和父节点
            if (child != n - 1 && arr[child] < arr[child + 1]) {
                child++; // 序号增1，指向右子树
            }

            // 如果父节点小于孩子结点，则需要交换
            if (father < arr[child]) {
                arr[i] = arr[child];
            } else {
                break; // 大顶堆结构未被破坏，不需要调整
            }
        }
        arr[i] = father;
    }

    // 获取到左孩子结点
    private static int leftChild(int i) {
        return 2 * i + 1;
    }

    // 交换元素位置
    private static void swap(int[] arr, int index1, int index2) {
        int tmp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = tmp;
    }

8. 基数排序(RadixSort)

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort.

8.1 基本思想

BinSort

BinSort想法非常简单，首先创建数组A[MaxValue]；然后将每个数放到相应的位置上（例如17放在下标17的数组位置）；最后遍历数组，即为排序后的结果。

BinSort

问题： 当序列中存在较大值时，BinSort 的排序方法会浪费大量的空间开销。

基数排序是在BinSort的基础上，通过基数的限制来减少空间的开销。

8.2 过程

RadixSort

RadixSort

（1）首先确定基数为10，数组的长度也就是10.每个数34都会在这10个数中寻找自己的位置。
（2）不同于BinSort会直接将数34放在数组的下标34处，基数排序是将34分开为3和4，第一轮排序根据最末位放在数组的下标4处，第二轮排序根据倒数第二位放在数组的下标3处，然后遍历数组即可。

8.3 算法实现

    /**
     * @Description: 基数排序 平均时间复杂度：O(d(n+r))
     * @Date:        13:53 2019/8/9
     * @Param:       [arrays]
     * @return:      int[]
     */
     static int[] radixSort(int[] arrays) {

        int max = findMax(arrays, 0, arrays.length - 1);

        //需要遍历的次数由数组最大值的位数来决定
        for (int i = 1; max / i > 0; i = i * 10) {
            int[][] buckets = new int[arrays.length][10];

            //获取每一位数字(个、十、百、千位...分配到桶子里)
            for (int j = 0; j < arrays.length; j++) {
                int num = (arrays[j] / i) % 10;

                //将其放入桶子里
                buckets[j][num] = arrays[j];
            }

            //回收桶子里的元素
            int k = 0;

            //有10个桶子
            for (int j = 0; j < 10; j++) {
                //对每个桶子里的元素进行回收
                for (int l = 0; l < arrays.length; l++) {

                    //如果桶子里面有元素就回收(数据初始化会为0)
                    if (buckets[l][j] != 0) {
                        arrays[k++] = buckets[l][j];
                    }
                }
            }
        }
        return arrays;
    }

    private static int findMax(int[] arrays, int L, int R) {

        //如果该数组只有一个数，那么最大的就是该数组第一个值了
        if (L == R) {
            return arrays[L];
        } else {
            int a = arrays[L];
            int b = findMax(arrays, L + 1, R);//找出整体的最大值
            if (a > b) {
                return a;
            } else {
                return b;
            }
        }
    }

9. 测试代码

/**
 * @author ：米奇罗
 * @className ：sortTest
 * @date ：Created in 2019/8/7 20:24
 * @description： 排序算法测试
 * @version: 1.0
 */
public class sortTest {
    public static void main(String[] args) {
        //int[] arr = {1};
        int[] arr = {3, 5, 2, 7, 5,10,4,3,11,10,22,4,8};
        //int[] arr = {3, 5, 2, 7,10,4,11,22,4,8};
        System.out.println("冒泡排序：");
        for (int i : sort.BubbleSort(arr)) {
            System.out.print(i + " ");
        }

        System.out.println();
        System.out.println("选择排序：");
        for (int i : sort.SelctionSort(arr)) {
            System.out.print(i + " ");
        }

        System.out.println();
        System.out.println("插入排序：");
        for (int i : sort.insert_sort(arr)) {
            System.out.print(i + " ");
        }

        System.out.println();
        System.out.println("希尔排序：");
        for (int i : sort.shell_sort(arr)) {
            System.out.print(i + " ");
        }

        System.out.println();
        System.out.println("快速排序：");
        for (int i : sort.quickSort(arr,0,arr.length-1)) {
            System.out.print(i + " ");
        }

        System.out.println();
        System.out.println("归并排序：");
        for (int i : sort.merge_sort(arr,0,arr.length-1)) {
            System.out.print(i + " ");
        }

        System.out.println();
        System.out.println("堆排序：");
        for (int i : sort.heapSort(arr)) {
            System.out.print(i + " ");
        }

        System.out.println();
        System.out.println("基数排序：");
        for (int i : sort.radixSort(arr)) {
            System.out.print(i + " ");
        }
    }
}

10. 排序算法复杂度总结

排序算法平均时间复杂度
冒泡排序O(n^2)
选择排序O(n^2)
插入排序O(n^2)
希尔排序O(n^1.5)
快速排序O(N*logN)
归并排序O(N*logN)
堆排序O(N*logN)
基数排序O(d(n+r))

11. 小结&参考资料

小结

算法对于Java开发人员来说，真的很重要，对于我这种当时上课没有好好的人来说，只能事后诸葛亮，自己重新学习算法了。加油！！！

此文是Java算法基础系列博客的第一篇，接下来，将会介绍贪心算法、
动态规划、分治算法、回溯算法等。敬请期待。。。

参考资料

米奇罗
关注
专栏目录
java-排序算法总结
02-27
冒泡排序是最基础的排序算法之一，通过不断交换相邻的错误顺序元素来逐步排序。Java中实现冒泡排序，通常会使用两层循环，外层控制排序次数，内层用于比较和交换元素。虽然效率较低，但易于理解。 2. 选择排序...
数据结构（Java）：七大排序算法【详解】
2401_83595513的博客
07-22 1436
七大排序算法——多方法、多实现、多优化、多细节【1.3w字详解】
详解Java常用排序算法（10种，含演示动画）
热门推荐
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-30 2万+
Java常用的排序算法有以下几种： 1. 冒泡排序；2. 选择排序；3. 插入排序；4. 希尔排序；5. 归并排序；6. 快速排序；7. 堆排序；8. 计数排序；9. 桶排序；10. 基数排序。 这些排序算法都有各自的优缺点，应根据具体情况选择适合的算法。
java算法编程基础知识
m0_61696809的博客
02-23 1723
数组Java 中数组是一种存储固定数量元素的数据结构，它具有以下特点：数组长度是固定的，一旦创建，长度就不能再改变。数组可以存储任意类型的数据，包括基本类型和对象类型。数组中的元素是有序的，可以通过下标访问。Java 中提供了一系列方法来处理数组，包括以下常用方法：1、创建数组Java 中使用关键字new来创建数组，语法如下：数据类型[] 数组名=new数据类型[数组长度];
JAVA基础算法
qwerasdctds的博客
07-28 423
​ 数据结构是数据存储的方式，算法是数据计算的方式。所以在开发中，算法和数据结构息息相关。今天的讲义中会涉及部分数据结构的专业名词，如果各位铁粉有疑惑，可以先看一下哥们后面录制的数据结构，再回头看算法。
Java-基础（数据结构与算法篇）
weixin_59413946的博客
07-17 5375
数据结构（data structure）：数据在计算机中的存储与组织形式；其主要目的是为了对数据进行高效地访问和修改；数据结构包含数组、链表这样的线性数据结构，也包含树、图这样的复杂数据结构。算法（algorithm）：在特定的计算模型下，旨在解决特定问题的一系列指令。程序 = 数据结构 + 算法。
八大排序-java实现版
03-01
八大排序java实现版本，直接插入排序、折半插入排序、冒泡排序、简单选择排序、希尔插入排序、快速排序 、堆排序、2-路归并排序 、基数排序，并有时间比较，博文...
基于Java语言的八大经典排序算法设计与实现源码详解
最新发布
10-05
本项目以Java语言为核心，深入解析并实现了八大经典排序算法，共计24个文件。其中包含8个Java类文件、4个XML配置文件、1个Git忽略文件、1个Markdown文件和1个Kotlin模块文件。项目内容丰富，图文并茂，详细阐述了每...
常见的八大排序算法及其JAVA实现
04-26
这八大排序算法包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序以及计数排序。 1. 冒泡排序（Bubble Sort）： 冒泡排序是最简单的排序算法之一，通过不断地交换相邻两个元素的位置，使较...
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip
09-15
在本压缩包“用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip”中，包含的是一个Java编程项目，主要目的是通过代码实践来理解和掌握数据结构、排序算法以及经典的计算机算法。...
java基础资料以及基本算法
10-09
java基础资料以及基本算法
40个java算法题，都弄会了，java基础就算入门了，很经典
06-13
【程序1】 题目：判断101-200之间有多少个素数，并输出所有素数。 1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除， 则表明此数不是素数，反之是素数。 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=2;i<=200;i++) if(mymath.iszhishu(i)==true) System.out.println(i); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } public boolean iszhishu(int x) { for(int i=2;i<=x/2;i++) if (x % 2==0 ) return false; return true; } } 【程序2】 题目：打印出所有的 "水仙花数 "，所谓 "水仙花数 "是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个 "水仙花数 "，因为153=1的三次方＋5的三次方＋3的三次方。 1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=100;i<=999;i++) if(mymath.shuixianhua(i)==true) System.out.println(i); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } public boolean iszhishu(int x) { for(int i=2;i<=x/2;i++) if (x % 2==0 ) return false; return true; } public boolean shuixianhua(int x) { int i=0,j=0,k=0; i=x / 100; j=(x % 100) /10; k=x % 10; if(x==i*i*i+j*j*j+k*k*k) return true; else return false; } }
JAVA 基础算法汇总（持续更新）
dayu199804的博客
04-14 1万+
前言 做一些基础数据结构算法汇总，便于日后复习。 一、查找算法 1.顺序查找（线性查找） 依据数组的下标按顺序进行查找，然后返回数组下标。对于数据量较小的情况，比较适用。但是如果数据量较大，花费的时间就比较多。 2.二分查找 二分查找Binary Search 二分查找的使用，要有一个前提条件：要查找的数必须在一个有序数组里。在这个前提下，取中间位置数作为比较对象： 若要查找的值和中间数相等，则查找成功。 若小于中间数，则在中间位置的左半区继续查找。 若大于中间数，则在中间位置...
程序员必须知道的10大基础实用算法及其讲解
zzjjiandan的专栏
06-17 869
程序员必须知道的10大基础实用算法及其讲解 算法一：快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
Java基础-算法
MMF博客园
12-16 412
Java基础-算法：冒泡排序、选择排序、二分查找
Java基础算法看这一篇就够了，简单全面一发入魂
学Java，找哪吒
05-18 1万+
一、算法 编写一段计算机程序一般都是实现一种已有的方法来解决某个问题。这种方法大多和使用的编程语言无关，它适用于各种计算机及编程语言。是这种方法而非计算机程序本身描述了解决问题的步骤。在计算机科学领域，我们用算法这个词来描述一种有限、确定、有效的并适合用计算机程序来实现的解决问题的方法。算法是计算机科学的基础，是这个领域的核心。 要定义一个算法，我们可以用自然语言描述解决某个问题的过程或是编写一点程序来实现这个过程。 大多数算法都需要适当地组织数据，而为了组织数据就产生了数据结构，数据结构也是计算机科学研究
面试中的排序算法总结
weixin_33722405的博客
03-05 2070
前言 　　查找和排序算法是算法的入门知识，其经典思想可以用于很多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。一般在面试中最常考的是快速排序和归并排序，并且经常有面试官要求现场写出这两种排序的代码。对这两种排序的代码一定要信手拈来才行。还有插入排序、冒泡排序、堆排序、基数排序、桶排序等。面试官对于这些排...
Java语言常用的算法
qq_45506362的博客
06-09 1万+
分治算法是一种递归的算法思想，其基本思想是将一个大问题分解为若干个小问题，分别解决这些小问题，最后将小问题的解合并起来得到大问题的解。二分查找，也称为折半查找，它要求数据集合必须是有序的，它的基本思想是将数据集合分成两半，如果目标元素比中间元素小，就在前半部分继续查找，否则在后半部分继续查找，直到找到目标元素或数据集合为空。在实际应用中，分治算法也可以用来解决很多实际问题，比如在计算机图形学中，将一个大的图形对象分解成若干个小的三角形对象，每个小对象单独处理后再合并成一个大对象。
java基本算法有哪些？
weixin_35754962的博客
02-11 736
Java 有许多基本算法，其中包括： 排序算法：快速排序、归并排序、冒泡排序等。 搜索算法：二分搜索、顺序搜索等。 哈希算法：用于存储和检索数据的散列表算法。 加密算法：如 AES、RSA 等。 图论算法：最短路径算法、最小生成树算法等。 字符串匹配算法：KMP 算法、Rabin-Karp 算法等。 动态规划：用于解决最优化问题的算法。 这仅仅是 Java 中一些常见的基本算法，...
Java编程：详解八大排序算法
"Java八大排序算法包括直接插入排序和希尔排序。直接插入排序是通过逐步将未排序元素插入已排序序列的正确位置来构建有序数组。希尔排序则是一种改进的插入排序，通过设置不同的增量序列来减少元素移动次数，提高...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值