排序算法——冒泡排序、直接插入排序、简单选择排序（Java）

最新推荐文章于 2024-07-10 17:31:57 发布
最新推荐文章于 2024-07-10 17:31:57 发布
阅读量225 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 排序算法 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52861211/article/details/129900187
版权

1.9.3 冒泡排序

介绍了解：
在这里插入图片描述
思路：

  • 每一趟排序将一个元素排序在一极
  • 优化思路：如果发现某一趟排序没有发生一次元素交换，那么可以判定该数组已经是有序的，即可结束冒泡排序
    在这里插入图片描述
    实现代码：

未优化前的冒泡排序

public static void bubbleSort(int[] array){ // 未优化前的冒泡排序
        System.out.println("未优化前冒泡排序: ");
        System.out.println("排序前数组: "+ Arrays.toString(array));
        long startTime = System.currentTimeMillis(); //起始时间
        // 默认升序排序
        for(int i=0;i<array.length-1;i++){  // 比如10个数字就需要排序9趟
            for(int j=0;j<array.length-1-i;j++){  // 每一趟需要对比9次数字大小,每一趟排序完可以确定一个极值数字，于是可以少对比一次数字大小
                if(array[j]>array[j+1]){
                    // 若前一位数值大于后一位数值,交换数值
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
            System.out.println("第"+i+"趟排序结果: "+Arrays.toString(array));
        }
        long endTime = System.currentTimeMillis();
        System.out.println("排序花费时间: "+(endTime-startTime));
    }

测试代码：

int[] array01 = {3,9,-1,10,-2};
bubbleSort(array01);

输出结果：

未优化前冒泡排序: 
排序前数组: [3, 9, -1, 10, -2]
第0趟排序结果: [3, -1, 9, -2, 10]
第1趟排序结果: [-1, 3, -2, 9, 10]
第2趟排序结果: [-1, -2, 3, 9, 10]
第3趟排序结果: [-2, -1, 3, 9, 10]

优化后的冒泡排序

  • 优化思路是定义一个flag变量，当在一趟排序的时候若有数据发生了交换，那么代表该数组还没完全有序，继续下一趟排序。若没有发生数据交换，那么代表该数组已然有序，即可跳出循环，结束排序。
  • 优化适用场景：
    • 此优化适用于数据量大且数据比较有序的情况。
    • 如果数据量小的而且数据乱序比较严重的话，此优化的效果比较差
public static void bubbleSort2(int[] array){
        System.out.println("优化后冒泡排序: ");
        System.out.println("排序前数组: "+ Arrays.toString(array));
        long startTime = System.currentTimeMillis(); //起始时间
        // 默认升序排序
        boolean flag;
        for(int i=0;i<array.length-1;i++){  // 比如10个数字就需要排序9趟
            flag = false;
            for(int j=0;j<array.length-1-i;j++){  // 每一趟需要对比9次数字大小,每一趟排序完可以确定一个极值数字，于是可以少对比一次数字大小
                if(array[j]>array[j+1]){
                    flag = true;
                    // 若前一位数值大于后一位数值,交换数值
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
            System.out.println("第"+i+"趟排序结果: "+Arrays.toString(array));
            if (!flag){
                System.out.println("该数组已有序排列!");
                break;
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("排序花费时间: "+(endTime-startTime));
    }

测试代码：

int[] array01 = {3,9,-1,10,-2};
bubbleSort2(array01);

输出结果：

优化后冒泡排序: 
排序前数组: [3, 9, -1, 10, -2]
第0趟排序结果: [3, -1, 9, -2, 10]
第1趟排序结果: [-1, 3, -2, 9, 10]
第2趟排序结果: [-1, -2, 3, 9, 10]
第3趟排序结果: [-2, -1, 3, 9, 10]

在数据量大情况下两种排序的花费时间比较 ：

import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Random;

public class bubbleSorting {
    public static void bubbleSort2(int[] array){
        System.out.println("优化后冒泡排序: ");
//        System.out.println("排序前数组: "+ Arrays.toString(array));
        long startTime = System.currentTimeMillis(); //起始时间
        // 默认升序排序
        boolean flag;
        for(int i=0;i<array.length-1;i++){  // 比如10个数字就需要排序9趟
            flag = false;
            for(int j=0;j<array.length-1-i;j++){  // 每一趟需要对比9次数字大小,每一趟排序完可以确定一个极值数字，于是可以少对比一次数字大小
                if(array[j]>array[j+1]){
                    flag = true;
                    // 若前一位数值大于后一位数值,交换数值
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
//            System.out.println("第"+i+"趟排序结果: "+Arrays.toString(array));
            if (!flag){
//                System.out.println("该数组已有序排列!");
                break;
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println("排序花费时间: "+(endTime-startTime));
    }
    public static void bubbleSort(int[] array){ // 未优化前的冒泡排序
        System.out.println("未优化前冒泡排序: ");
//        System.out.println("排序前数组: "+ Arrays.toString(array));
        long startTime = System.currentTimeMillis(); //起始时间
        // 默认升序排序
        for(int i=0;i<array.length-1;i++){  // 比如10个数字就需要排序9趟
            for(int j=0;j<array.length-1-i;j++){  // 每一趟需要对比9次数字大小,每一趟排序完可以确定一个极值数字，于是可以少对比一次数字大小
                if(array[j]>array[j+1]){
                    // 若前一位数值大于后一位数值,交换数值
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
//            System.out.println("第"+i+"趟排序结果: "+Arrays.toString(array));
        }
        long endTime = System.currentTimeMillis();
        System.out.println("排序花费时间: "+(endTime-startTime));
    }
    public static void main(String[] args) {
        // 生成随机无序数组
        int[] array = new int[1000];
        Random random = new Random();
        for(int i=0;i<1000;i++){
            array[i] = random.nextInt(1500);
        }
        bubbleSort(array);
        bubbleSort2(array);
    }
}

输出结果：

未优化前冒泡排序: 
排序花费时间: 4
优化后冒泡排序: 
排序花费时间: 0

1.9.4 选择排序

介绍：
在这里插入图片描述
在这里插入图片描述
思路：
在这里插入图片描述
实现代码与输出结果：

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Random;

public class selectSortDemo {
    public static void selectSort(int[] array){ // 默认升序排序
        System.out.println("排序前: "+ Arrays.toString(array));
        long startTime = System.currentTimeMillis();
        for (int i=0;i<array.length-1;i++){ // n个数排序只需要排序n-1趟
            int minIndex = i; // 初始化最小值和最小值下标
            int min;
            for (int j=i+1;j<array.length;j++){ // 从第i+1个数字开始寻找极值
                if (array[minIndex] > array[j]){
                    minIndex = j; // 更新记录的最小数的下标
                }
            }
            if (minIndex != i){ // 只要minIndex发生了变化 就需要交换最小值，确保最小值处于最左端
                min = array[minIndex];
                array[minIndex] = array[i];
                array[i] = min;
            }
            System.out.println("第"+i+"趟选择排序: "+Arrays.toString(array));
        }
        long endTime = System.currentTimeMillis();
        System.out.println("排序花费时间: "+(endTime-startTime));
    }
    public static void main(String[] args) {
        // 测试代码一
        int[] array = {101,34,119,1,-1,90,123};
        selectSort(array);

        // 测试代码二: 因为数据太多,建议把打印数组代码注释
//        int[] array2 = new int[1000];
//        Random random = new Random();
//        for(int i=0;i<1000;i++){ // 生成随机无序数组
//            array2[i] = random.nextInt(1500);
//        }
//        selectSort(array2);
    }
}

输出结果：

排序前: [101, 34, 119, 1, -1, 90, 123]
第0趟选择排序: [-1, 34, 119, 1, 101, 90, 123]
第1趟选择排序: [-1, 1, 119, 34, 101, 90, 123]
第2趟选择排序: [-1, 1, 34, 119, 101, 90, 123]
第3趟选择排序: [-1, 1, 34, 90, 101, 119, 123]
第4趟选择排序: [-1, 1, 34, 90, 101, 119, 123]
第5趟选择排序: [-1, 1, 34, 90, 101, 119, 123]
排序花费时间: 1

1.9.5 插入排序

介绍：
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
思路：

  • 将原来数组分为两份表,一份为有序表,开始时默认只有原数组的第一个元素。另外一份为无序表，为原数组未排序的元素集合
  • 每次遍历无序表一个元素，将该元素插入到有序表内，在插入过程中需要根据插入元素的大小判别插入的位置
  • 看如下动态图加深理解
    • 在往有序表插入新元素的时候，会先在原有序表最后一个数字后一位空一个位置temp出来（该位置实际上是插入数字insertValue的位置）
    • 然后插入数字insertValue会与temp前一位数字frontValue进行大小比较
    • 若insertValue < frontValue 那么temp向前移动一位，frontValue向后移动一位。之后insertValue重新会与temp新的前一位数字frontValue进行数值比较
    • 直到insertValue > frontValue 或者 将有序表所有数字都比较过（这就代表insertValue比有序表最小数据还小，直接插入有序表第一个位置即可）
    • 当跳出while循环的时候insertValue指针指向的是insertValue要插入位置的前一位地址，所以插入赋值的时候需要将insertIndex+1
动图

实现代码与输出结果：

import java.lang.reflect.Array;
import java.util.Arrays;

public class insertSort {
    public static void insertSortFunction(int[] array){ // 默认从小到大排序
        System.out.println("排序前: "+ Arrays.toString(array));
        for (int i=1;i<array.length;i++){ // 第一个元素默认加入到有序表内
            int insertValue = array[i];
            int insertIndex = i-1;
            // 判断插入数据insertValue是否处于array[0]——array[End]之间
            // 想要修改排序为降序只需要修改 insertValue < array[insertIndex]
            while (insertIndex >=0 && insertValue < array[insertIndex]){ 
                array[insertIndex+1] = array[insertIndex]; // 将frontValue后移一位
                insertIndex--; // 将temp前移一位
            }
            // 当跳出循环的时候 说明找到插入数据的插入位置了,并insertIndex指针指向插入位置前一位
            array[insertIndex+1] = insertValue; // 插入值
            System.out.println("第"+i+"趟插入排序: "+Arrays.toString(array));
        }
    }
    public static void main(String[] args) {
        int[] array = {101,34,119 ,1,-1,89};
        insertSortFunction(array);
    }
}

输出结果：

排序前: [101, 34, 119, 1, -1, 89]
第1趟插入排序: [34, 101, 119, 1, -1, 89]
第2趟插入排序: [34, 101, 119, 1, -1, 89]
第3趟插入排序: [1, 34, 101, 119, -1, 89]
第4趟插入排序: [-1, 1, 34, 101, 119, 89]
第5趟插入排序: [-1, 1, 34, 89, 101, 119]
m0_52861211
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之冒泡排序与直接插入排序
m0_46295884的博客
02-14 2010
文章目录前言一、冒泡排序二、直接插入排序 前言 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 直接插入排序（Straigh
Java实现排序（快速排序、冒泡排序、选择排序、基数排序、插入排序）
cjp627156的专栏
04-14 521
<br />/*<br /> * To change this template, choose Tools | Templates<br /> * and open the template in the editor.<br /> */<br />package javasort;<br />import java.util.ArrayList;<br />import java.util.LinkedList;<br />import java.util.List;<br />import java.
【数据结构之排序系列】直接插入排序，冒泡排序，直接选择排序，堆排序，希尔排序
胡坚涛的博客
01-30 1578
排序算法章节在校招方面考察是相对比较频繁的，所以本章中所学习的所有排序算法需要引起很大的重视。需要掌握各种排序算法的时间复杂度
直接插入排序和冒泡排序比较
qq_37941471的博客
05-30 6528
直接插入排序 ： 思想：将数组中的所有元素依次和前面的已经排好序的元素相比较（依次），如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过。 代码实现： Sort.h: #pragma once #include &amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;gt; using namespace std; #include &amp;amp;amp;amp;lt;assert.h&amp;amp;a
插入排序、冒泡排序、选择排序、希尔排序、堆排序、快速排序、归并排序
qq_56324572的博客
01-07 538
对一个区间的元素进行排序，在这个区间中任选一个元素（一般挑区间最边上的元素--最右边的， pivot ），遍历整个待排序区间，将每个元素都和 pivot 作比较（=），同时把 pivot 放到合适的位置，要求所有（= pivot ）的元素都在 pivot 右边。无序区间少了一个元素，有序区间多了一个元素。[无序区间] [有序区间] 中，将无序区间维护成一个大堆（从小到大排序，需要大堆），利用大堆从无序区间中找到最大值，交换。
冒泡排序和插入排序（详解）
m0_73790767的博客
11-07 3406
c语言冒泡排序
简单排序算法（冒泡排序、选择排序、插入排序、希尔排序）
Ronz 的博客
01-10 989
java 排序算法 冒泡排序 选择排序 直接插入排序 希尔排序
26.2、排序算法1
08-08
在本文中，我们将深入探讨两种经典的排序算法——直接插入排序和冒泡排序。 1、直接插入排序（Direct Insertion Sort） 直接插入排序是一种简单的排序方法，它的基本思想是将待排序的数据看作是一个有序序列和一个...
排序算法源代码
11-07
常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等。 2. **Java实现的排序算法**： Java作为一种面向对象的语言，其丰富的类库和高效性能使得它成为实现排序算法的常用选择。在Java中...
十大经典排序——java实现（csdn）————程序.pdf
12-05
十大经典排序算法_java实现 排序算法是学习算法的入门篇，了解各种排序算法是非常重要的。在正式介绍各种排序算法前，先介绍一下要用到的一些术语： 稳定排序：如果a本来在b的前面，且a==b，排序以后a依旧在b的...
直接，快速，冒泡，选择，二分查找排序
04-23
本文将详细介绍五种经典的排序算法：直接插入排序、冒泡排序、选择排序和快速排序，以及一种查找算法——二分查找，并提供Java语言的实现。 一、直接插入排序 直接插入排序是一种简单直观的排序算法。它的工作原理...
排序算法c&java描述
01-10
本资源包包含了两种编程语言——C和Java对于排序算法的详细描述，旨在帮助应聘者更好地理解和掌握这些算法，以应对软件公司的笔试挑战。 首先，让我们探讨排序算法的基本概念。排序是将一组无序的数据元素按照特定...
排序算法——冒泡排序和插入排序
2301_77237568的博客
03-26 408
插入排序比较的次数与无序数组的长度相等，每次无序数组与有序数组中的所有元素进行比较，比较后找到相应的位置插入，最后得到一个有序数组。它重复地走访过要排序的数列，一次比较两个元素，按照从小到大或从大到小的顺序排序，不断比较相邻的两个值，较大或较小的元素前移。通过构建有序数组元素的存储，对未排序的数组元素，在已排序的数组中从最后一个元素向第一个元 素遍历，找到相应位置并插入。比如数组 [2,3,1,4,5] 经过排序成为了 [1,2,3,4,5] 或者 [5,4,3,2,1]
冒泡排序、选择排序和直接插入排序
lv121218的博客
11-09 603
冒泡排序、选择排序和直接插入排序
冒泡排序VS直接插入排序
weixin_42617262的博客
03-09 691
冒泡排序VS直接插入排序 我们先思考一个问题：如何衡量一个排序算法的优劣呢？ 一般来讲我们可从三个方面来看： 1.算法的时间效率： a.时间复杂度：最好、最坏、平均时间复杂度相结合判断。 b.时间复杂度系数、低阶、常数的影响（因只有元素数量足够多时才可忽略系数、低阶、常数的影响，否则不可忽略）。 c.比较交换次数。 2.算法的内存消耗： 通过空间复杂度衡量。 3.算法的稳定性（重要） 算法的稳定性...
简单排序——选择排序、冒泡排序、插入排序
weixin_65472178的博客
05-24 2769
本文利用示例和图示的方法详细阐述了简单排序（选择排序、冒泡排序、插入排序）的算法原理和过程，并给出对应的代码供读者参考。
Java经典算法之冒泡排序(Bubble Sort)
woniu_maggie的博客
08-09 2409
如上例：第一趟比较之后，排在最后的一个数一定是最大的一个数，第二趟排序的时候，只需要比较除了最后一个数以外的其他的数，同样也能找出一个最大的数排在参与第二趟比较的数后面，第三趟比较的时候，只需要比较除了最后两个数以外的其他的数，以此类推……由此可见：N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数，即;j++) // 内循环是比较的次数N-i。第三次排序：6和1比较，6大于1，交换位置： 2 3 1 6 8 9。
【Java】Java实现冒泡排序、简单选择排序、直接插入排序
devnn的专栏
11-07 862
插入排序和冒泡排序的时间复杂度都是O(n^2)，都是稳定排序算法，但是插入排序不存在交换元素，比冒泡少两次操作，整体上优于冒泡排序。选择排序时间复杂度是O(n^2)，但它是不稳定排序算法。冒泡排序时间复杂度是O(n^2)，它是稳定排序算法。
【排序 - 快速排序】
最新发布
2302_80393814的博客
07-10 653
快速排序通过分治策略和分区操作，实现了高效的排序。它不需要额外的存储空间（除了递归调用时的栈空间），并且在平均情况下具有较好的性能表现。因此，快速排序是实际应用中常用的排序算法之一，尤其适合大数据集的排序任务。
Java实现常见排序算法总结
05-02
除了直接插入排序外，还有许多其他常见的排序算法，如冒泡排序、选择排序、快速排序等。每种排序算法都有其适用的场景和优势，理解和掌握这些排序算法对于提高程序的执行效率和优化算法性能是非常重要的。 总的来说...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值