Java算法篇-排序算法

已于 2024-05-22 09:33:46 修改
阅读量591 收藏 17
点赞数 16
分类专栏： 算法 Java 文章标签： 算法 java 排序算法 经验分享 笔记
于 2024-05-21 11:43:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46909938/article/details/139086393
版权

目录

 一、排序算法-冒泡排序

1、算法原理

2、原理图讲解冒泡排序流程

3、算法代码demo

二、排序算法-选择排序

1、算法原理

2、原理图讲解选择排序流程

3、算法代码demo

三、排序算法-插入排序

1、算法原理

2、原理图讲解插入排序流程

3、算法代码demo

四、排序算法-快速排序

1、算法原理

2、原理图讲解快速排序流程

3、算法代码demo

五、参考代码（可以自己跑一下，debug看看数据变化的原理）

📢📢📢📣📣📣
哈喽！大家好，我是「Leen」。刚工作几年，想和大家一同进步🤝🤝
一位上进心十足的Java博主！😜😜😜
喜欢尝试一些新鲜的东西，平时比较喜欢研究一些新鲜技术和一些自己没有掌握的技术领域。能用程序解决的坚决不手动解决😜😜😜

目前已涉足Java、Python、数据库（MySQL、pgsql、MongoDB、Oracle...）、Linux、HTML、VUE、PHP、C（了解不多，主要是嵌入式编程方向做了一些）...（还在不断地学习，扩展自己的见识和技术领域中），希望可以和各位大佬们一起进步，共同学习🤝🤝

✨ 如果有对【Java】，或者喜欢看一些实操笔记感兴趣的【小可爱】，欢迎关注我

❤️❤️❤️感谢各位大可爱小可爱！❤️❤️❤️
————————————————

如果觉得本文对你有帮助，欢迎点赞，欢迎关注我，如果有补充欢迎评论交流，我将努力创作更多更好的文章。

前言

Java常见十四种算法

Java经典基础十大算法

Java语言常用的算法包括：
排序算法：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序等。

查找算法：顺序查找、二分查找、哈希查找等。

字符串匹配算法：暴力匹配、KMP算法、Boyer-Moore算法等。

图论算法：最短路径算法、最小生成树算法、拓扑排序等。

动态规划算法：背包问题、最长公共子序列、最长上升子序列等。

贪心算法：最小生成树、单源最短路径等。

分治算法：快速排序、归并排序等。

网络流算法：最大流问题、最小割问题等。

数学算法：欧几里得算法、素数判断、大数计算等。

本次文章内容主要展示排序算法中的几个算法demo

 一、排序算法-冒泡排序

1、算法原理

        比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 

2、原理图讲解冒泡排序流程

①初始的无序数列 {5,8,6,3,9,2,1,7}，希望对其升序排序

②按照思路分析：

3bb7cf853f3a6791f506d21616b61340.png

在经过第一轮交换后，最大的数 9 冒泡到了最右边

23e9411b5503a0e4802dd74e2010644a.png

到此为止，所有元素都是有序的了，这就是冒泡排序的整体思路。

3、算法代码demo

public static void bubbleSort(int[] arr) {
        // 获取数组的长度
        int n = arr.length;

        // 外层循环，负责控制排序的轮数
        // 因为每一轮排序都会将当前未排序部分的最大值“冒泡”到末尾
        // 所以需要循环 n-1 次（最后一个元素在倒数第二轮就已经确定位置）
        for (int i = 0; i < n - 1; i++) {
            // 内层循环，负责每一轮的冒泡过程
            // 因为每一轮都会有一个元素被确定位置（即“冒泡”到末尾）
            // 所以内层循环需要减少一次比较
            for (int j = 0; j < n - i - 1; j++) {
                // 如果当前元素比下一个元素大
                // 则交换这两个元素的位置，实现“冒泡”
                if (arr[j] > arr[j + 1]) {
                    // 使用临时变量 temp 来交换两个元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            // 完成一轮冒泡后，最大的数已经被“冒泡”到末尾
            // 所以下一轮就不需要再对最后一个元素进行比较了
        }
        // 当所有轮数都执行完毕后，数组就已经有序了
    }

二、排序算法-选择排序

1、算法原理

        选择排序是一种简单直观的排序算法，其基本思路是在未排序的序列中找到最小（或最大）元素，然后将其存放到序列的起始位置。

伪代码：

// 选择排序算法的伪代码
for 当前位置 from 0 to n-2
    // 找到从当前位置到末尾的最小值
    for 比较位置 from 当前位置+1 to n-1
        if 比较位置的值小于当前最小值
            记录较小值的位置
    // 交换当前位置与最小值位置
    交换当前位置与记录的最小值位置

2、原理图讲解选择排序流程

动图demo

3、算法代码demo

 public static void selectionSort(int[] arr) {
        // 获取数组的长度
        int n = arr.length;

        // 外层循环，控制排序的轮数
        // 从第一个元素开始，依次往后进行n-1轮选择
        for (int i = 0; i < n - 1; i++) {
            // 假设当前未排序部分的最小值索引就是i
            int minIndex = i;

            // 内层循环，在未排序部分中寻找最小值
            for (int j = i + 1; j < n; j++) {
                // 如果发现更小的元素
                if (arr[j] < arr[minIndex]) {
                    // 更新最小值的索引
                    minIndex = j;
                }
            }

            // 找到最小值后，将其与未排序部分的第一个元素交换位置
            // 交换前先将未排序部分的第一个元素保存到临时变量temp中
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;

            // 经过一轮选择后，i位置上的元素就是未排序部分的最小值
            // 下一轮从i+1位置开始选择
        }
        // 当所有轮数都执行完毕后，数组就已经有序了
    }

三、排序算法-插入排序

1、算法原理

        插入排序是一种简单直观的排序算法，其工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

伪代码：

插入排序(int[] arr) {
    对于数组中的每个元素:
    1. 使用key保存当前元素的值，并假设当前元素是已排序区间的最后一个元素
    2. 从已排序区间开始向前扫描
    3. 如果扫描到的元素大于key，将其移到下一位置
    4. 重复步骤3，直到找到已排序区间中小于或等于key的元素
    5. 将key插入到找到的位置中
}

2、原理图讲解插入排序流程

动图演示demo

3、算法代码demo

 public static void insertionSort(int[] arr) {
        // 获取数组的长度
        int n = arr.length;

        // 从数组的第二个元素开始（索引为1），因为第一个元素默认是已排序的
        for (int i = 1; i < n; i++) {
            // 当前要插入的元素
            int key = arr[i];

            // j为已排序部分的最后一个元素的索引，初始化为i-1
            int j = i - 1;

            // 将大于key的元素向后移动一位
            // 循环直到找到key应该插入的位置或者到达数组的起始位置
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }

            // 找到key应该插入的位置后，将其插入
            arr[j + 1] = key;
        }
    }

四、排序算法-快速排序

1、算法原理

        Java快速排序是一种高效的排序算法，由东尼·霍夫曼在1962年提出。其基本思路是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序。

快速排序的基本步骤如下：

        ①选择一个基准元素，通常选择数组的第一个元素或最后一个元素。

        ②重新排列数组，将所有比基准元素小的元素放在基准元素之前，所有比基准元素大的元素放在基准元素之后。在这个分区结束之后，基准元素就处于数组的中间位置。这个操作称为分区（partition）。

        ③递归地把小于基准元素的子数组和大于基准元素的子数组进行快速排序。

2、原理图讲解快速排序流程

3、算法代码demo

public static void quickSort(int[] arr, int left, int right) {
        // 如果left大于或等于right，说明当前区间内没有元素或只有一个元素，无需排序
        if (left >= right) {
            return;
        }

        // 选择基准元素（pivot），这里选择的是left位置的元素
        int pivot = arr[left];

        // i是小于pivot的元素的索引
        int i = left;
        // j是大于等于pivot的元素的索引
        int j = right;

        // 交换元素，使得arr[left..i]都是小于pivot的，arr[i+1..j]都是大于等于pivot的
        // 当i < j时，继续循环
        while (i < j) {
            // 从右向左找到第一个小于pivot的元素
            while (i < j && arr[j] >= pivot) {
                j--;
            }
            // 将找到的小于pivot的元素放到arr[i]位置
            arr[i] = arr[j];

            // 从左向右找到第一个大于等于pivot的元素
            while (i < j && arr[i] <= pivot) {
                i++;
            }
            // 将找到的大于等于pivot的元素放到arr[j]位置
            // 注意：此时arr[i]的值已经被覆盖，所以需要将arr[j]的值放到arr[i]
            arr[j] = arr[i];
        }

        // 将pivot元素放到最终的位置
        arr[i] = pivot;

        // 递归对pivot左边和右边的子数组进行快速排序
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }

五、参考代码（可以自己跑一下，debug看看数据变化的原理）

package com.leen.test.test2024.test507;

/**
 * Author:Leen
 * Date: 2024/5/7 17:29
 */

import java.util.Arrays;

/**
 * 排序算法
 */
public class SortingAlgorithm {

    public static void main(String[] args) {
        //定义数组
        int[] arr = new int[10];
        arr[0] = 767;
        arr[1] = 67468;
        arr[2] = 496;
        arr[3] = 3463;
        arr[4] = 3213;
        arr[5] = 7676;
        arr[6] = 5876;
        arr[7] = 245;
        arr[8] = 425;
        arr[9] = 5158;
        System.out.println(Arrays.toString(arr));
        //冒泡
//        bubbleSort(arr);
        //选择
//        selectionSort(arr);
        //插入
//        insertionSort(arr);
        //快速
        quickSort(arr,0, arr.length-1);
        System.out.println(Arrays.toString(arr));

    }
    /**
     * 冒泡排序
     * 冒泡排序是最简单的排序算法之一，
     * 其基本思想是将相邻的两个元素进行比较，如果顺序不对就交换它们的位置。
     * 这段代码的时间复杂度是 O(n^2)，其中 n 是数组的长度。
     * 在最坏的情况下（即数组完全逆序时），每一轮都需要进行 n-1-i 次比较和可能的交换。
     * 最好的情况下（即数组已经有序），比较次数会大大减少，但内层循环仍然会执行，所以时间复杂度仍然是 O(n^2)。
     * 空间复杂度是 O(1)，因为算法只需要常数级别的额外空间（即临时变量 temp）。
     * @param arr
     */
    public static void bubbleSort(int[] arr) {
        // 获取数组的长度
        int n = arr.length;

        // 外层循环，负责控制排序的轮数
        // 因为每一轮排序都会将当前未排序部分的最大值“冒泡”到末尾
        // 所以需要循环 n-1 次（最后一个元素在倒数第二轮就已经确定位置）
        for (int i = 0; i < n - 1; i++) {
            // 内层循环，负责每一轮的冒泡过程
            // 因为每一轮都会有一个元素被确定位置（即“冒泡”到末尾）
            // 所以内层循环需要减少一次比较
            for (int j = 0; j < n - i - 1; j++) {
                // 如果当前元素比下一个元素大
                // 则交换这两个元素的位置，实现“冒泡”
                if (arr[j] > arr[j + 1]) {
                    // 使用临时变量 temp 来交换两个元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            // 完成一轮冒泡后，最大的数已经被“冒泡”到末尾
            // 所以下一轮就不需要再对最后一个元素进行比较了
        }
        // 当所有轮数都执行完毕后，数组就已经有序了
    }

    /**
     * 选择排序
     * 选择排序的基本思想是每次选择未排序序列中最小的元素，将其放到已排序序列的末尾。
     * 这段代码的时间复杂度是O(n^2)，其中n是数组的长度。
     * 每一轮选择最小值时，都需要遍历一次未排序部分，因此总共需要进行n-1次这样的遍历。
     * 空间复杂度是O(1)，因为只使用了常量级的额外空间（即一个临时变量temp）。
     * 选择排序是一种原地排序算法，它只需要用到O(1)的额外空间。
     * @param arr
     */
    public static void selectionSort(int[] arr) {
        // 获取数组的长度
        int n = arr.length;

        // 外层循环，控制排序的轮数
        // 从第一个元素开始，依次往后进行n-1轮选择
        for (int i = 0; i < n - 1; i++) {
            // 假设当前未排序部分的最小值索引就是i
            int minIndex = i;

            // 内层循环，在未排序部分中寻找最小值
            for (int j = i + 1; j < n; j++) {
                // 如果发现更小的元素
                if (arr[j] < arr[minIndex]) {
                    // 更新最小值的索引
                    minIndex = j;
                }
            }

            // 找到最小值后，将其与未排序部分的第一个元素交换位置
            // 交换前先将未排序部分的第一个元素保存到临时变量temp中
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;

            // 经过一轮选择后，i位置上的元素就是未排序部分的最小值
            // 下一轮从i+1位置开始选择
        }
        // 当所有轮数都执行完毕后，数组就已经有序了
    }

    /**
     * 插入排序
     * 插入排序的基本思想是将未排序序列中的每个元素插入到已排序序列的合适位置。
     * 这段代码的时间复杂度是O(n^2)，其中n是数组的长度。
     * 在最坏的情况下（即数组完全逆序时），内层循环需要执行n-1次，每次外层循环时内层循环都需要执行几乎完整的n次比较和移动操作。
     * 空间复杂度是O(1)，因为插入排序只需要常数级别的额外空间。
     * @param arr
     */
    public static void insertionSort(int[] arr) {
        // 获取数组的长度
        int n = arr.length;

        // 从数组的第二个元素开始（索引为1），因为第一个元素默认是已排序的
        for (int i = 1; i < n; i++) {
            // 当前要插入的元素
            int key = arr[i];

            // j为已排序部分的最后一个元素的索引，初始化为i-1
            int j = i - 1;

            // 将大于key的元素向后移动一位
            // 循环直到找到key应该插入的位置或者到达数组的起始位置
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }

            // 找到key应该插入的位置后，将其插入
            arr[j + 1] = key;
        }
    }

    /**
     * 快速排序
     * 快速排序的基本思想是选择一个基准元素，将序列分成两部分，一部分元素比基准元素小，一部分元素比基准元素大，然后分别对这两部分进行快速排序。
     * 该算法的时间复杂度为O(nlogn)。
     * 注意：
     * 1、基准元素（pivot）的选择：这里选择的是arr[left]，但在实际实现中，基准元素的选择有多种方式，比如随机选择、三数取中等，这些方式可以在一定程度上避免最坏情况的发生。
     * 2、索引i和j的初始化和移动：i从左边开始向右移动，直到找到一个大于等于pivot的元素；j从右边开始向左移动，直到找到一个小于pivot的元素。然后交换这两个元素的位置。
     * 3、递归调用：当i和j相遇（即i = j）时，将pivot放到arr[i]（或arr[j]）位置，然后分别对pivot左边和右边的子数组进行快速排序。
     * @param arr
     * @param left
     * @param right
     */
    public static void quickSort(int[] arr, int left, int right) {
        // 如果left大于或等于right，说明当前区间内没有元素或只有一个元素，无需排序
        if (left >= right) {
            return;
        }

        // 选择基准元素（pivot），这里选择的是left位置的元素
        int pivot = arr[left];

        // i是小于pivot的元素的索引
        int i = left;
        // j是大于等于pivot的元素的索引
        int j = right;

        // 交换元素，使得arr[left..i]都是小于pivot的，arr[i+1..j]都是大于等于pivot的
        // 当i < j时，继续循环
        while (i < j) {
            // 从右向左找到第一个小于pivot的元素
            while (i < j && arr[j] >= pivot) {
                j--;
            }
            // 将找到的小于pivot的元素放到arr[i]位置
            arr[i] = arr[j];

            // 从左向右找到第一个大于等于pivot的元素
            while (i < j && arr[i] <= pivot) {
                i++;
            }
            // 将找到的大于等于pivot的元素放到arr[j]位置
            // 注意：此时arr[i]的值已经被覆盖，所以需要将arr[j]的值放到arr[i]
            arr[j] = arr[i];
        }

        // 将pivot元素放到最终的位置
        arr[i] = pivot;

        // 递归对pivot左边和右边的子数组进行快速排序
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }


}

欢迎大家在评论区讨论，今天的干货分享就到此结束了，如果觉得对您有帮助，麻烦给个三连！

以上内容为本人的经验总结和平时操作的笔记。若有错误和重复请联系作者删除！！感谢支持！！

Leen@
关注
  • 16
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java算法练习-双栈排序练习题
10-01
[Java]算法练习-双栈排序练习题
详解Java常用排序算法-插入排序
08-26
Java排序算法 - 插入排序 插入排序（Insertion Sort）是一种简单的排序算法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增 1 的有序表。该算法的实现非常简单，但其时间复杂度...
详解Java常用排序算法-选择排序
08-26
详解Java常用排序算法-选择排序 选择排序（Selection Sort）是一种简单的排序算法，它的基本思想是每次从待排序的元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的元素排完。 选择...
java-排序算法总结
02-27
本篇将深入探讨Java中实现的几种主要排序算法，并提供相关的范文、模板和素材。 1. 冒泡排序（Bubble Sort） 冒泡排序是最基础的排序算法之一，通过不断交换相邻的错误顺序元素来逐步排序。Java中实现冒泡排序，...
详解Java常用排序算法-归并排序
08-26
Java常用排序算法-归并排序 归并排序是一种分治思想的排序算法，其基本思想是将待排序的数组分成若干个子序列，每个子序列都是有序的，然后再将子序列合并成一个有序的数组。这种算法的时间复杂度为O(n log n)，...
CSP 2020 第三题：表达式
m0_46183615的博客
08-03 366
CSP 2020 第三题：表达式
【前端面试】七、算法-递归、拷贝等
weixin_49015558的博客
07-30 425
1.常考算法 2.遍历方法 3.链式调用 4.递归 5.拷贝和比较
【秋招笔试】2024-08-03-科大讯飞秋招笔试题(算法岗)-三语言题解(CPP/Python/Java)
清隆学长的博客
08-04 183
> 🍖 本次题目难度中等偏上，最后一题又是笔试常驻嘉宾树形DP > >1️⃣ 第一题其实是个诈骗题，发现图其实都不需要读入，本质是一个 `置换环` > > 2️⃣ 第二题比较签到是个简单的 `字符串处理` > > 3️⃣ 第三题是笔试常驻嘉宾 `树形DP`，建议大家好好练练，树形DP属于会者不难，难者不会的这一类。
学习笔记--算法（双指针）2
weixin_71085457的博客
08-01 543
学习笔记，自用！！
学习笔记--算法（双指针）5
weixin_71085457的博客
08-04 500
学习自用！！
【算法】分治算法以及用分治算法解决汉诺塔问题
2302_78914800的博客
08-04 143
分治算法的思想是 “ 分而治之 ” ，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题......知道最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础。
算法通关：017_1：二叉树及三种顺序的递归遍历
m0_75257168的博客
08-04 257
二叉树及三种顺序的递归遍历。
秋招突击——算法练习——8/3——马上消费笔试总结——{距离为一的字符串、组合数遍历}
Blackoutdragon的博客
08-04 554
这两道题虽然是比较简单，但是我做的并不好，并没通过所有的样例，但是学到了很多东西，纠正了很多以前做题的坏习惯，总结一下，具体如下 判断引用对象相等用equal 使用完Collections.sort记得恢复现场 后续在加油！今天很棒！
算法刷题之哈希表
m0_73906588的博客
08-04 144
哈希的核心思想是把需要的数据提前计算并存储，常见的哈希结构：数组、set、map。
浅谈位运算及其应用（c++）
2301_79587247的博客
07-31 567
位运算在 C++ 中是一种强大而灵活的工具，掌握它可以让我们在编程中更加高效地处理数据、优化性能，并实现一些复杂而有趣的功能。但同时，我们也要注意其使用的场景和可能带来的潜在问题，以确保代码的正确性和可维护性。希望通过这篇博客，您对位运算在 C++ 中的应用有了更深入的理解和认识，能够在实际编程中灵活运用，创造出更优秀的程序。
力扣第五十二题——N皇后II
m0_74932528的博客
08-04 603
研究的是如何将n个皇后放置在n × n的棋盘上，并且使皇后彼此之间不能相互攻击。给你一个整数n，返回不同的解决方案的数量。n = 42如上图所示，4 皇后问题存在两个不同的解法。n = 11。
算法力扣刷题总结篇 ——【五】二叉树章节
danaaaa的博客
08-02 888
二叉树题目总结篇
C语言指针（2）
最新发布
m0_62048999的博客
08-04 567
一、数组名的理解 1、&arr[0]与arr 有时候我们需要获取数组首元素，有两种方法可以获取。 使用这两种方法都可以获得数组首元素&arr[0]，arr。
从数学角度理解SVM分类算法
weixin_66519663的博客
08-02 1387
不过，在间隔最大化的运算中只使用了高维向量内积运算的结果，并没有单独使用高维向量，也就是说，如果能简单地求出高维向量的内积，那么也可以满足求解间隔最大化的条件。注意：对于已知的映射函数 φ，核函数是很容易计算的，但在大多数情况下，我们并不知道映射函数 φ 的具体形式，好在伟大的数学家们已经证明，在无法得出 φ 时，只要数学函数满足几个相应条件，同样可以将其作为核函数，因此不用担心找不到核函数。注意：上述公式中被除数是分子，除数是 L2 范式的简要写法，当 i = 3 时，与上述点到三维平面的距离公式相同。
Java排序算法详解与实现
【资源摘要信息】: "Java排序算法汇总，包括插入排序、交换排序、选择排序、归并排序和基数排序。适用于不同规模和顺序的数组，选择合适的排序算法能提高效率。" 在计算机科学中，排序算法是用于对一组数据进行排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Leen@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值