Java 常用的几种排序方式：冒泡.选择.插入.快排.希尔排序.归并排序.基数排序及其优化

最新推荐文章于 2024-10-02 23:40:03 发布
最新推荐文章于 2024-10-02 23:40:03 发布
阅读量258 收藏
点赞数 1
文章标签： 算法 java 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58679358/article/details/126793923
版权

一.冒泡排序

        注:此处用了异或运算符

 public static int[] sort(int[] arr) {
        int temp = 0;
        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]) {
                    flag = true;
                    arr[j] = arr[j] ^ arr[j + 1];
                    arr[j + 1] = arr[j] ^ arr[j + 1];
                    arr[j] = arr[j] ^ arr[j + 1];
                }
            }
            System.out.printf("第%d次排序:", i+1);
            System.out.println(Arrays.toString(arr));
        }
        return arr;
    }

 优化思路：有可能在前几次排序后已经完成排序，但是仍然会进行判断。

                   如果未发生交换则排序已经完成，则可以退出排序

    public static int[] sort(int[] arr) {
        int temp = 0;
        boolean flag = false;
        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]) {
                    flag = true;
                    arr[j] = arr[j] ^ arr[j + 1];
                    arr[j + 1] = arr[j] ^ arr[j + 1];
                    arr[j] = arr[j] ^ arr[j + 1];
                }
            }
            if (flag != true) {
                break;
            } else {
                flag=false;
            }
            System.out.printf("第%d次排序:", i+1);
            System.out.println(Arrays.toString(arr));
        }
        return arr;
    }

二.选择排序

          在整个数组按照指定规则选择出一个元素放在排序的正确位置

 public static int[] sort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = 0;
            int min = arr[i];

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

        return arr;
    }

三.插入排序

        默认前i个元素是有序的让第i+1个元素插入前一个元素组成的有序数组中

public static int[] sort(int[] arr) {

        for (int i = 1; i < arr.length; i++) {
            // 待插入的数
            int insertVal = arr[i];
            int insertIndex = i - 1;  //待插入数前一个数

            while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
                arr[insertIndex + 1] = arr[insertIndex];
                insertIndex--;
            }
            arr[insertIndex + 1] = insertVal;

            System.out.printf("第%d轮",i);
            System.out.println(Arrays.toString(arr));
        }

        return arr;
    }

四.希尔排序

1.交换法

 public static int[] swapsSrt(int[] arr) {
        int length = arr.length;
        int temp = 0;
        for (int gap = length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < length; i++) {
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
        return arr;
    }

2.移动法

public static int[] moveSort(int[] arr) {
        int length = arr.length;
        int temp = 0;

        for (int gap = length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < length; i++) {
                int j = i;
                temp = arr[j];
                if (arr[j] < arr[j - gap]) {
                    while (j - gap >=  0 && temp < arr[j - gap]) {
                        //移动
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    arr[j] = temp;
                }
            }
        }
        return arr;
    }

五.归并排序

1.分

public static void mergeSort(int[] arr, int left, int right, int [] temp) {
        if (left < right) {
            int mid = (left + right) / 2;
            //向左
            mergeSort(arr, left, mid, temp);
            //向右
            mergeSort(arr, mid + 1, right, temp);

            merge(arr,left,mid,right,temp);
        }
    }

2.治

public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left;
        int j = mid + 1;
        int t = 0; //用于指向临时数组

        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t++;
                i++;
            } else {
                temp[t] = arr[j];
                t++;
                j++;
            }
        }
        //有剩余
        while (i <= mid) {
            temp[t] = arr[i];
            i++;
            t++;
        }
        while (j <= right) {
            temp[t] = arr[j];
            j++;
            t++;
        }
        /**
         *     拷贝到原数组
         *     第一次    0 1
         *     第二次    2 3
         *     第三次    0 3
         */
        t = 0;
        int tempLeft = left;
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }
    }

六.基数排序

public static int[] sort(int[] arr) {

        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) max = arr[i];
        }

        int maxNum = (max + "").length();

        // 设置10个桶
        int[][] bucket = new int[10][arr.length];

        // 记录每个桶存放的数据
        int[] bucketElement = new int[10];

        for (int k = 0, n = 1; k < maxNum; k++, n *= 10) {

            for (int i = 0; i < arr.length; i++) {
                int digitOfElement = arr[i] / n % 10;
                // 放入对应的桶中
                bucket[digitOfElement][bucketElement[digitOfElement]] = arr[i];
                bucketElement[digitOfElement]++;
            }
            // 按顺序取出放入原来的桶中
            int index = 0;

            for (int i = 0; i < bucketElement.length; i++) {
                // 有数据就取出
                if (bucketElement[i] != 0) {
                    for (int j = 0; j < bucketElement[i]; j++) {
                        arr[index++] = bucket[i][j];
                    }
                }
                bucketElement[i] = 0;
            }
        }
        return arr;
    }

七.快速排序

public static int[] sort(int[] arr, int left, int right) {

        int l = left;
        int r = right;
        int temp = 0;

        // 取中间值
        int pivot = arr[(left + right) / 2];

        while (l < r) {

            while (arr[l] < pivot) {
                l += 1;
            }

            while (arr[r] > pivot) {
                r -= 1;
            }

            //左边全是小于pivot 右边全部大于pivot
            if (l >= r) {
                break;
            }

            //进行交换
//            temp = arr[l];
//            arr[l] = arr[r];
//            arr[r] = temp;
            arr[r] = arr[r] ^ arr[l];
            arr[l] = arr[r] ^ arr[l];
            arr[r] = arr[r] ^ arr[l];

            if (arr[l] == pivot) {
                r -= 1;
            }

            if (arr[r] == pivot) {
                l += 1;
            }
        }

        if (l == r) {
            l += 1;
            r -= 1;
        }

        //向左递归
        if (left < r) {
            sort(arr, left, r);
        }
        //向右递归
        if (right > l) {
            sort(arr, l, right);
        }
        return arr;
    }

我是一条弱鸡
关注
排序算法（冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、基数排序）
wardo_l的博客
03-18 6078
排序也叫排序算法，排序是将一组数据，依指定的顺序进行排列的过程。 排序的分类： 1）内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序。 2）外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。 3）常见的排序算法分类： 内部排序： （1）插入排序：直接插入排序、希尔排序 （2）选择排序：简单选择排序、堆排序 （3）交换排序：冒泡排序、快速排序 （4）归并排序、基数排序 我们先回顾知识点：时间复杂度 时间频度：一个算法花费的时间与算法中语句的执行次数成正比例
八大排序算法的Java实现
yuhaomogui的博客
11-26 888
选择排序、冒泡排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、基数排序
Java实现常用的排序算法（快速排序、归并排序、基数排序）
weixin_46073538的博客
09-13 895
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。快速排序又是一种分而治之思想在排序算法上的典型应用。
常见排序方式：冒泡、选择、插入、希尔、快速、归并，基数
dayuiicghaid的博客
07-24 334
冒泡排序 1.优点:比较简单,空间复杂度较低，是稳定的； 2.缺点:时间复杂度太高，效率慢； 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。 选择排序 　缺点：比较次数多；不稳定。 选择排序（Select...
十大排序算法（冒泡排序、插入排序、选择排序、希尔排序、堆排序、快排、归并排序、桶排序、计数排序、基数排序）
2301_80215560的博客
03-10 1万+
十大排序算法（冒泡排序、插入排序、选择排序、希尔排序、堆排序、快排、归并排序、桶排序、计数排序、基数排序）十大排序的思想和代码的实现！！！
排序算法-冒泡、选择、堆、插入、归并、快速、希尔
伟庭的博客
08-15 804
排序算法-冒泡、选择、堆、插入、归并、快速、希尔
【算法】排序算法(插入排序、希尔排序、选择排序、冒泡排序、快速排序、归并排序、基数排序、堆排序)
热门推荐
酷酷的馫博客
12-18 1万+
八大排序算法(插入排序、希尔排序、选择排序、冒泡排序、快速排序、归并排序、基数排序、堆排序)
Java 常见排序算法（冒泡，插入，选择，快速，归并，希尔，堆排序，基数）
qq_42185491的博客
05-16 144
面试中经常会遇到一些排序的问题，在此总结一下java中常见的几种排序算法，快速，归并，冒泡，插入，希尔，基数，选择，堆排序。 参考：https://www.cnblogs.com/chengxiao/p/6194356.html 排序算法在线演示图：http://tools.jb51.net/aideddesign/paixu_ys 冒泡排序 冒泡排序个人认为是最简单最容易理解的一种排序算法，它的基本原理是依次比较数组中相邻的两个元素，从前到后，如果后面的元素大于前面的元素，就交换两个元素的位置，
【JavaSE与数据结构】排序算法之冒泡排序，选择排序，插入排序与希尔排序
未见花闻的博客
02-21 1155
本篇文章带大家认识排序算法——冒泡排序，选择排序，插入排序与希尔排序，其中冒泡排序，选择排序，插入排序是基础的排序算法，希尔排序是插入排序的优化，四种排序算法全部都是基于比较的排序算法，本文将以图解动图的方式描述算法实现过程，实现代码为java。
数据结构——排序算法（冒泡排序、选择排序、插入排序、归并排序、快速排序、搜索算法）
qq_52301431的博客
08-25 1149
如果有一天你面试的时候, 让你写一个排序算法, 你可以洋洋洒洒的写出多个排序算法, 但是如果其中没有快速排序, 那么证明你对排序算法也只是浅尝辄止, 并没有深入的研究过.- 对于N个数据项呢?- 如果2位置元素小于1位置的元素, 那么将0位置的元素移动到1位置, 并且将2位置的元素放在0位置, 0 - 1 - 2搞定.选择排序第一次将第0位置的人取出, 和后面的人(1, 2, 3...)依次比较, 如果后面的人更小, 那么就交换..........
算法-排序算法（冒泡、快排、直接插入、希尔、简单选择、堆排序、归并、基数）
等闲之辈莫等闲的博客
03-29 1332
文章目录介绍 更多算法可以参考算法汇总传送门 介绍 排序算法（Sort Algorithm），排序是将一组数据，依指定的顺序进行排列的过程。 分类 内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序 外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行拍讯 常见的排序算法分类： 未完待续~ .........
75从零开始学Java之排序算法中的直接插入、快排和希尔排序
一一哥
05-29 1034
在上一篇文章中，壹哥给大家介绍了冒泡排序和选择排序，这两种算法都是排序算法。实际上排序算法还有插入、希尔、快速排序等，接下来我们就来学习一下这几种排序算法。前戏已做完，精彩即开始全文大约【5400】字，不说废话，只讲可以让你学到技术、明白原理的纯干货！本文带有丰富的案例及配图视频，让你更好地理解和运用文中的技术概念，并可以给你带来具有足够启迪的思考......接下来我们把插入排序的特性总结一下。
Java - 常用的比较排序（快排、归并）
旧时言的博客
02-16 487
1.概念 1.1排序 排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。平时的上下文中，如果提到排序，通常指的是排升序（非降序）。通常意义上的排序，都是指的原地排序(in place sort)。 1.2稳定性（重要） 两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算 法。 2.七大基于比较的排序-总览 3.插入排序 3.1直接插入排序-原理 整个区间被分为 1.有序区间 2.无序区间 每次选择无序区间的第一个元素，
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1279
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
2301_80161204的博客
09-27 467
25[0, 105]
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1007
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
最新发布
wnm23的专栏
10-02 511
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1280
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
Java排序算法详解：冒泡、选择、插入、Shell及归并
本文将详细介绍Java中几种常见的排序算法，包括冒泡排序、选择排序、插入排序、Shell排序以及归并排序。 1. **冒泡排序**： 冒泡排序是最简单的排序算法之一，它通过重复遍历待排序的数组，比较相邻元素并交换位置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值