【java】冒泡排序/选择排序/希尔排序

news2024/11/25 14:19:52

文章目录

  • 排序分类/排序算法的分类
  • 冒泡排序
    • 代码1：
    • 代码2（优化
    • 代码3（算法优化 --当次排序没有进行交换则退出循环
    • 代码4（封装为方法
    • 代码5（检测冒泡排序时间复杂度
  • 选择排序
    • 代码1
    • 代码2（优化算法
    • 代码3（计算时间复杂度
  • 插入排序
    • 代码
    • 时间复杂度
  • 希尔排序
    • 交换法
    • 时间复杂度
    • 移位法（效率高

排序分类/排序算法的分类

在这里插入图片描述

冒泡排序

介绍
在这里插入图片描述

模拟/思路讲解
在这里插入图片描述

数组转换成String类型输

代码1：

package Sort;

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

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3,9,-1,10,-2};//从小到大排序

        //第一趟排序 就是将最大的数排在最后
        int temp = 0;//临时变量
        for (int i = 0; i < arr.length-1; i++) {
            if (arr[i] > arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第一趟排序后的数组：");
        //???toString
        System.out.println(Arrays.toString(arr));

        //第二趟排序 就是第二大的数排在倒数第二位
        for (int i = 0; i < arr.length - 2; i++) {
            if (arr[i] > arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第二趟排序后的数组：");
        //???toString
        System.out.println(Arrays.toString(arr));

        //第三趟排序 就是将第三大的数排在倒数第三位
        for (int i = 0; i < arr.length - 3; i++) {
            if (arr[i] > arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第三趟排序后的数组：");
        //???toString
        System.out.println(Arrays.toString(arr));

        //第四趟排序 就是将第四大的数排在倒数第三位
        for (int i = 0; i < arr.length - 4; i++) {
            if (arr[i] > arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
        System.out.println("第四趟排序后的数组：");
        //???toString
        System.out.println(Arrays.toString(arr));
    }
}

代码2（优化

package Sort;

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

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3,9,-1,10,-2};//从小到大排序

        //第一趟排序 就是将最大的数排在最后
        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]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.println("第"+(i+1)+"趟排序后的数组：");
            System.out.println(Arrays.toString(arr));
        }

    }
}

在这里插入图片描述

代码3（算法优化 --当次排序没有进行交换则退出循环

package Sort;

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

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3,-1,9,10,20};//从小到大排序

        //第一趟排序 就是将最大的数排在最后
        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;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            System.out.println("第"+(i+1)+"趟排序后的数组：");
            System.out.println(Arrays.toString(arr));

            if (!flag){
                break;
            }else {
                flag = false;
            }
        }
    }
}

在这里插入图片描述

代码4（封装为方法

在这里插入图片描述

代码5（检测冒泡排序时间复杂度

package Sort;

import java.lang.reflect.Array;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class BubbleSort {
    public static void main(String[] args) {
//        int arr[] = {3,-1,9,10,20};//从小到大排序
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int)(Math.random() * 8000000);//生成[0,8000000)的数
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间是="+date1Str);

        //测试冒泡排序
        bubbleSort(arr);

        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后的时间是="+date2Str);
    }
    public static void bubbleSort(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;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
//            System.out.println("第"+(i+1)+"趟排序后的数组：");
//            System.out.println(Arrays.toString(arr));

            if (!flag){
                break;
            }else {
                flag = false;
            }
        }
    }
}

在这里插入图片描述

冒泡排序时间复杂度：O(n2 )

选择排序

选择排序思路：
在这里插入图片描述

图解流程：
在这里插入图片描述

代码1

package Sort;

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101, 119, 34,1};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        selectSort(arr);
    }

    public static void selectSort(int[] arr) {
        //第1轮
        int minIndex = 0;
        int min = arr[0];
        for (int i = 0 + 1; i < arr.length; i++) {
            if (min > arr[i]) {//说明假定的最小值不是最小的
                min = arr[i];   //重置min
                minIndex = i;   //重置minIndex
            }
        }
//        System.out.println("minIndex = "+minIndex);
//        System.out.println("min = "+min);

        //将最小值元素与arr[0] 两者交换
        if (minIndex != 0){
            arr[minIndex] = arr[0];
            arr[0] = min;
        }
        System.out.println("第1轮后：");
        System.out.println(Arrays.toString(arr));

        //第2轮
         minIndex = 1;
         min = arr[1];
        for (int i = 1 + 1; i < arr.length; i++) {
            if (min > arr[i]) {//说明假定的最小值不是最小的
                min = arr[i];   //重置min
                minIndex = i;   //重置minIndex
            }
        }
        //将最小值元素与arr[0] 两者交换
        if (minIndex != 1){
            arr[minIndex] = arr[1];
            arr[1] = min;
        }
        System.out.println("第2轮后：");
        System.out.println(Arrays.toString(arr));

        //第3轮
         minIndex = 3;
         min = arr[3];
        for (int i = 2 + 1; i < arr.length; i++) {
            if (min > arr[i]) {//说明假定的最小值不是最小的
                min = arr[i];   //重置min
                minIndex = i;   //重置minIndex
            }
        }
        //将最小值元素与arr[0] 两者交换
        if (minIndex != 3){
            arr[minIndex] = arr[2];
            arr[2] = min;
        }
        System.out.println("第3轮后：");
        System.out.println(Arrays.toString(arr));
    }
}

在这里插入图片描述

代码2（优化算法

package Sort;

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {101, 119, 34,1,-1,90,123};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(arr));
        selectSort(arr);

        System.out.println("排序后：");
        System.out.println(Arrays.toString(arr));
    }

    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            //第1轮
            int minIndex = i;
            int min = arr[i];
            for (int j = i + 1; j < arr.length; j++) {
                if (min > arr[j]) {//说明假定的最小值不是最小的
                    min = arr[j];   //重置min
                    minIndex = j;   //重置minIndex
                }
            }
            //将最小值元素与arr[0] 两者交换
            if (minIndex != i){
                arr[minIndex] = arr[i];
                arr[i] = min;
            }
//            System.out.println("第"+(i+1)+"轮后：");
//            System.out.println(Arrays.toString(arr));
        }
    }
}

在这里插入图片描述

选择排序的时间复杂度是O(n2 )
比冒泡排序快的原因：
多了个判断筛选，减小循环次数

代码3（计算时间复杂度

main内

//计算选择排序的时间复杂度
        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int)(Math.random() * 8000000);//生成[0,8000000)的数
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间是="+date1Str);

        //测试冒泡排序
        selectSort(arr);

        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后的时间是="+date2Str);

在这里插入图片描述

插入排序

思想
在这里插入图片描述
思路图
在这里插入图片描述

代码

package Sort;

import java.util.Arrays;

public class InsertSort {
    public static void main(String[] args) {
        //从小到大
        int[] arr = {101,34,119,1,-1,89};
        insertSort(arr);
    }
    public static void insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int insertVal = arr[i];
            int insertIndex = i-1;  //arr[1]前面数的下标
            //1.insertIndex >= 0：保证不越界
            //2.insertVal < arr[insertIndex]还没找到插入位置
            while (insertIndex >= 0 && insertVal < arr[insertIndex]){
                arr[insertIndex+1] = arr[insertIndex]; //将arr[insertIndex]后移
                insertIndex--;//让arr[1]再和前面的数进行比较
            }
            //当退出while循环时 说明插入的位置找到 insertIndex+1(因为
            // 1.insertIndex可能--多了
            // 2.就算arr[1]=334则一开始不需要insertIndex-1
            arr[insertIndex + 1] = insertVal;

            System.out.println("第"+i+"轮插入：");
            System.out.println(Arrays.toString(arr));
        }
    }

}

优化：

if (insertIndex+1 != i){
                arr[insertIndex + 1] = insertVal;
            }

例如arr[1]一开始为334 则不需要任何交换排序

时间复杂度

main内

int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int)(Math.random() * 8000000);//生成[0,8000000)的数
        }
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间是="+date1Str);

        //测试冒泡排序
        insertSort(arr);

        Date date2 = new Date();
        String date2Str = simpleDateFormat.format(date2);
        System.out.println("排序后的时间是="+date2Str);

在这里插入图片描述

希尔排序

插入排序存在的问题-效率低下
在这里插入图片描述
希尔排序图解
在这里插入图片描述
在这里插入图片描述
希尔排序的两种应用方法
在这里插入图片描述

交换法

package Sort;

import java.util.Arrays;

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {8,9,1,7,2,3,5,4,6,0};
        shellSort1(arr);
    }

    //使用交换法
    public static void shellSort1(int[] arr){
        int temp = 0;
        int count = 0;
        //第1轮
        //10个数据分为了5组
        for(int gap = arr.length/2;gap > 0;gap /= 2){
            for (int i = gap; i < arr.length; i++) {
                //遍历各组中所有的元素（共gap组） 步长为gap
                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;
                    }
                }
            }
            System.out.println("希尔排序的第"+(++count)+"轮 = "+ Arrays.toString(arr));
        }

    }
}

在这里插入图片描述

时间复杂度

代码同上
在这里插入图片描述

反而比插入排序更慢了

加上弹幕说的break后时间变成了不到1秒，why啊！？谢谢你陌生人（呵呵

答案：减少forj的循环判断

移位法（效率高

//使用交换法
    public static void shellSort1(int[] arr){
        int temp = 0;
        int count = 0;
        //第1轮
        //10个数据分为了5组
        for(int gap = arr.length/2;gap > 0;gap /= 2){
            for (int i = gap; i < arr.length; i++) {
                //遍历各组中所有的元素（共gap组） 步长为gap
                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;
                        break;
                    }
                }
            }
//            System.out.println("希尔排序的第"+(++count)+"轮 = "+ Arrays.toString(arr));
        }

在这里插入图片描述

效率也比方法一高

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/169211.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

FinalShell的下载安装简单使用

FinalShell的下载安装简单使用

目录 一、下载 二、安装 三、简单使用 一、下载 下载地址&#xff1a;SSH工具 SSH客户端 1、进去后选择第一个 FinalSheel SSH工具,远程桌面加速软件,支持Windows,macOS,Linux,版本3.9.7,更新时间2022.10.26&#xff1b; 2、选择需要的版本下载&#xff0c;我选择的是&…
阅读更多...
80. 循环神经网络的简洁实现

80. 循环神经网络的简洁实现

虽然从零开始实现循环神经网络对了解循环神经网络的实现方式具有指导意义&#xff0c;但并不方便。 本节将展示如何使用深度学习框架的高级API提供的函数更有效地实现相同的语言模型。 我们仍然从读取时光机器数据集开始。 import torch from torch import nn from torch.nn i…
阅读更多...
【SpringCloud13】SpringCloud Config分布式配置中心

【SpringCloud13】SpringCloud Config分布式配置中心

1.概述 1.1 分布式系统面临的配置问题 微服务意味着要将单体应用中的业务拆分成一个个子服务&#xff0c;每个服务的粒度相对较小&#xff0c;因此系统中会出现大量的服务。由于每个服务都需要必要的配置信息才能运行&#xff0c;所以一套集中式的、动态的配置管理设施是必不…
阅读更多...
PointNext论文解读

PointNext论文解读

论文地址&#xff1a;https://arxiv.org/abs/2206.04670 github地址&#xff1a;GitHub - guochengqian/PointNeXt: [NeurIPS22] PointNeXt: Revisiting PointNet with Improved Training and Scaling Strategies 本文主要提出优化PointNet的两大关键点. 1) 好的训练策略 2…
阅读更多...
如何搭建一个专业的知识库

如何搭建一个专业的知识库

当客户跟你达成合作关系后&#xff0c;需要持续的关系维护&#xff0c;在一定的销售点&#xff0c;定期和客户沟通&#xff0c;据调查&#xff0c;赢得一个新客户的成本可能是保留一个现有客户的5到25倍&#xff0c;作为营销策略&#xff0c;客户服务支持必须满足他们的期望。建…
阅读更多...
[BJDCTF2020]Easy MD5（浅谈PHP弱类型hash比较缺陷）

[BJDCTF2020]Easy MD5（浅谈PHP弱类型hash比较缺陷）

目录 信息收集 构造payload PHP弱类型hash比较缺陷 0e碰撞 数组MD5 总结 信息收集 看题目应该和MD5加密相关 select * from admin where passwordmd5($pass,true) PHP的MD5函数 string必需。规定要计算的字符串。raw 可选。规定十六进制或二进制输出格式&#xff1a; …
阅读更多...
2023-01-17 PostgreSQL 并行查询概述

2023-01-17 PostgreSQL 并行查询概述

简介&#xff1a; 大数据时代&#xff0c;人们使用数据库系统处理的数据量越来越大&#xff0c;请求越来越复杂&#xff0c;对数据库系统的大数据处理能力和混合负载能力提出更高的要求。PostgreSQL 作为世界上最先进的开源数据库&#xff0c;在大数据处理方面做了很多工作&…
阅读更多...
详谈ORB-SLAM2的单目初始化器Initializer

详谈ORB-SLAM2的单目初始化器Initializer

单目初始化器Initializer类&#xff0c;这个类只用于单目初始化&#xff0c;因为这是ORB-SLAM里遗留的一个类&#xff0c;也是祖传代码&#xff0c;双目和RGBD相机只需要一帧就能初始化&#xff0c;因为双目和RGBD相机拍到的点都是有信息的&#xff0c;但是单目相机就不一定了&…
阅读更多...
六种方法在云平台和远程桌面中使用Kali

六种方法在云平台和远程桌面中使用Kali

一、说明 本篇主要介绍方便在云服务器&#xff0c;或者以远程桌面&#xff08;GUI&#xff09;形式使用kali配置教程&#xff0c;帮助渗透更加方便顺利。 二、方法 2.1 方法一 云服务提供商预装 备注&#xff1a;预算充足&#xff0c;可以首考虑此方法 优点&#xff1a; 云服…
阅读更多...
java 探花交友项目实战 day3 完善个人信息 阿里云OSS文件存储 百度人脸识别

java 探花交友项目实战 day3 完善个人信息 阿里云OSS文件存储 百度人脸识别

完善用户信息 业务概述 阿里云OSS Data ConfigurationProperties(prefix "tanhua.oss") public class OssProperties { private String accessKey; private String secret; private String bucketName; private String url; //域名 private Strin…
阅读更多...
微分方程的特征值解法：斯图姆-刘维尔方程

微分方程的特征值解法：斯图姆-刘维尔方程

一.基础概念 前置：福克斯定理和奇点理论 常点的级数解 奇异点的级数解 则至少存在一个如下形式的解（弗罗贝尼乌斯级数）： 19世纪中期，常微分方程的研究到了新的阶段，存在定理和斯图姆-刘维尔理论都假设微分方程区域内含解析函数或至少包含连续函数，而另一方面，以前研究…
阅读更多...
东莞注塑MES管理系统具有哪些功能

东莞注塑MES管理系统具有哪些功能

伴随着人们对于物质生活的品质要求越来越高&#xff0c;日用品、医疗保健、汽车工业、电子行业、新能源、家电、包装行业以及建筑等行业对注塑产品的需求量日益突出。注塑企业提供的各种各样的塑料产品已渗透到经济生活的各个领域&#xff0c;为国家经济的各个部门包括轻工业和…
阅读更多...
ARM SD卡启动详解

ARM SD卡启动详解

一、主流的外存设备介绍 内存和外存的区别&#xff1a;一般是把这种 RAM(random access memory&#xff0c;随机访问存储器&#xff0c;特点是任意字节读写&#xff0c;掉电丢失)叫内存&#xff0c;把 ROM&#xff08;read only memory&#xff0c;只读存储器&#xff0c;类似…
阅读更多...
15子空间投影

15子空间投影

子空间投影 从向量的投影入手&#xff0c;延伸到高维投影&#xff0c;并将投影使用矩阵形式给出。做投影也即向另一个向量上做垂线。上一章讨论的Axb无解时的最优解求解时&#xff0c;并没有解释这个最优解为何“最优”&#xff0c;本节课给出相应的解释。相对简单的二维空间的…
阅读更多...
MyBatis -- resultType 和 resultMap

MyBatis -- resultType 和 resultMap

MyBatis -- resultType 和 resultMap一、返回类型&#xff1a;resultType二、返回字典映射&#xff1a;resultMap一、返回类型&#xff1a;resultType 绝⼤数查询场景可以使用 resultType 进⾏返回&#xff0c;如下代码所示&#xff1a; <select id"getNameById"…
阅读更多...
企业如何借助制造业ERP系统，做好生产排产管理？

企业如何借助制造业ERP系统，做好生产排产管理？

随着市场竞争越来越激烈&#xff0c;生产制造行业订单零碎化趋势越发突出。面对品种多&#xff0c;数量小&#xff0c;批次多&#xff0c;个性化需求也多的生产方式&#xff0c;PMC生产排产管理变得非常困难&#xff1b;同时生产过程还会有各种不确定的临时性因素出现&#xff…
阅读更多...
详解pandas的read_csv函数

详解pandas的read_csv函数

一、官网参数 pandas官网参数网址&#xff1a;pandas.read_csv — pandas 1.5.2 documentation 如下所示&#xff1a; 二、常用参数详解 1、filepath_or_buffer(文件) 一般指读取文件的路径。比如读取csv文件。【必须指定】 import pandas as pddf_1 pd.read_csv(r"C:…
阅读更多...
Xilinx FPGA电源设计与注意事项

Xilinx FPGA电源设计与注意事项

1 引言随着半导体和芯片技术的飞速发展&#xff0c;现在的FPGA集成了越来越多的可配置逻辑资源、各种各样的外部总线接口以及丰富的内部RAM资源&#xff0c;使其在国防、医疗、消费电子等领域得到了越来越广泛的应用。当采用FPGA进行设计电路时&#xff0c;大多数FPGA对上电的电…
阅读更多...
软件测试复习06：基于经验的测试

软件测试复习06：基于经验的测试

作者&#xff1a;非妃是公主 专栏&#xff1a;《软件测试》 个性签&#xff1a;顺境不惰&#xff0c;逆境不馁&#xff0c;以心制境&#xff0c;万事可成。——曾国藩 文章目录软件缺陷基于缺陷分类的测试缺陷模式探索性测试软件缺陷 主要由以下几种原因造成&#xff1a; 疏…
阅读更多...
Redux相关知识（什么是redux、redux的工作原理、redux的核心概念、redux的基本使用）(十一)

Redux相关知识（什么是redux、redux的工作原理、redux的核心概念、redux的基本使用）(十一)

系列文章目录 第一章&#xff1a;React基础知识&#xff08;React基本使用、JSX语法、React模块化与组件化&#xff09;&#xff08;一&#xff09; 第二章&#xff1a;React基础知识&#xff08;组件实例三大核心属性state、props、refs&#xff09;&#xff08;二&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023