Java数据结构与算法笔记——冒泡排序、选择排序、插入排序

最新推荐文章于 2023-02-13 17:09:27 发布
最新推荐文章于 2023-02-13 17:09:27 发布
阅读量170 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Wanderer/article/details/112407720
版权

文章目录

算法原理写的一窍不通，想了解原理的小伙伴们还是找几张动图吧。不过本文的代码可用！
本文图片来自网络。

冒泡排序

乱七八糟的描述

数组：arr
两个指针：inner和outer。
初始：inner指向第一位，outer指向最后一位。

比较arr[inner]和arr[inner+1]的大小，如果arr[inner+1]>arr[inner]，就交换两者的位置。
inner后移，重复上述操作，直至inner=outer-1，outer向前移位。
直至outer指向数组第二位，即outer=1（并进行了上述操作）。

图解

在这里插入图片描述

package demo;

public class MaopaoPai {
    public static void main(String[] args){
        ArrayClassBub arrayClassBub = new ArrayClassBub(100);

        arrayClassBub.insert(11);
        arrayClassBub.insert(23);
        arrayClassBub.insert(45);
        arrayClassBub.insert(21);
        arrayClassBub.insert(66);
        arrayClassBub.insert(77);
        arrayClassBub.insert(66);
        arrayClassBub.insert(1);

        arrayClassBub.display();

        arrayClassBub.bubSort();

        arrayClassBub.display();
    }
}


/**
 * 创建一个封装数组的类
 */

class ArrayClassBub{
    private long[] arr; //被封装的数组
    private int nElems; //数组中存在的元素的个数，当前的数组长度

    //通过类的构造方法初始化
    public ArrayClassBub(int maxSize){ //数组的最大长度
        arr = new long[maxSize]; //初始化被封装的数组
        nElems = 0;
    }

    //新增数据项，数组元素
    public void insert(long data){
        arr[nElems] = data;
        nElems ++;
    }

    //查找某一特定的数据项
    //找到返回true，否则返回false
    public boolean find(long searchData){
        int i;
        for (i=0;i<nElems;i++){
            if(searchData == arr[i]){
                break;//找到了就直接终止循环，此时i不再++，就等于对应元素的索引值
            }
        }
        if(i == nElems){
            return false;
        }
        else{
            return true;
        }
    }

    //删除指定的数据项
    public void delete(long targetDate){
        //首先找到要删除的数据
        int i;
        for (i=0;i<nElems;i++){
            if(targetDate == arr[i]){
                break;//找到了就直接终止循环，此时i不再++，就等于对应元素的索引值
            }
        }
        if(i == nElems){
            System.out.println("没有找到要删除的数据");
        }
        else{
            for(int j =i;j<nElems;j++){
                arr[j] = arr[j+1]; //删除数组中要删除的元素
            }
            nElems --; //数组长度-1
        }
    }

    //遍历数据结构中的各个数据项
    public void display(){
        for(int i=0;i<nElems;i++){
            System.out.print(arr[i] + "  ");
        }
        System.out.println();//加一个换行符
    }

    /**
     * 实现冒泡排序，为无序数组排序，从小到大
     */
    public void bubSort(){
        int outer;
        int inner;

        for(outer=nElems-1;outer>=1;outer--){
            for(inner=0;inner<outer;inner++){
                if(arr[inner] > arr[inner+1]){ //前面元素比后面元素大，交换位置
                    long temp=arr[inner];
                    arr[inner] = arr[inner+1];
                    arr[inner+1] = temp;
                }
            }
        }
    }
}

选择排序

乱七八糟的描述

数组：arr
三个指针：inner、outer和min。
初始：outer和min指向第一个位置，inner指向第二个位置。

inner往后移动，如果inner指向的位置比min小，就把min移到inner位置。
当inner指向数组最后一位，且执行了上述操作后，将min指的项和outer指的项换位，outer向后移一位。
直至当outer指向倒数第二位（并进行了上述操作）。

图解

在这里插入图片描述

package demo;

public class SelectPaixu {
    //程序的执行入口
    public static void main(String[] args){
        ArrayClassSelect arrayClassSelect = new ArrayClassSelect(100);

        arrayClassSelect.insert(11);
        arrayClassSelect.insert(23);
        arrayClassSelect.insert(45);
        arrayClassSelect.insert(21);
        arrayClassSelect.insert(66);
        arrayClassSelect.insert(77);
        arrayClassSelect.insert(66);
        arrayClassSelect.insert(1);
        
        arrayClassSelect.display();

        arrayClassSelect.selectSort();

        arrayClassSelect.display();
    }
}

/**
 * 创建一个封装数组的类
 */

class ArrayClassSelect{
    private long[] arr; //被封装的数组
    private int nElems; //数组中存在的元素的个数，当前的数组长度

    //通过类的构造方法初始化
    public ArrayClassSelect(int maxSize){ //数组的最大长度
        arr = new long[maxSize]; //初始化被封装的数组
        nElems = 0;
    }

    //新增数据项，数组元素
    public void insert(long data){
        arr[nElems] = data;
        nElems ++;
    }

    //查找某一特定的数据项
    //找到返回true，否则返回false
    public boolean find(long searchData){
        int i;
        for (i=0;i<nElems;i++){
            if(searchData == arr[i]){
                break;//找到了就直接终止循环，此时i不再++，就等于对应元素的索引值
            }
        }
        if(i == nElems){
            return false;
        }
        else{
            return true;
        }
    }

    //删除指定的数据项
    public void delete(long targetDate){
        //首先找到要删除的数据
        int i;
        for (i=0;i<nElems;i++){
            if(targetDate == arr[i]){
                break;//找到了就直接终止循环，此时i不再++，就等于对应元素的索引值
            }
        }
        if(i == nElems){
            System.out.println("没有找到要删除的数据");
        }
        else{
            for(int j =i;j<nElems;j++){
                arr[j] = arr[j+1]; //删除数组中要删除的元素
            }
            nElems --; //数组长度-1
        }
    }

    //遍历数据结构中的各个数据项
    public void display(){
        for(int i=0;i<nElems;i++){
            System.out.print(arr[i] + "  ");
        }
        System.out.println();//加一个换行符
    }

    /**
     * 实现选择排序，从小到大
     */
    public void selectSort(){
        int outer;
        int inner;
        int min;

        for(outer=0;outer<nElems-1;outer++){
            min = outer; //每次循环初始化min变量指向outer位置，即剩下元素的第一个
            for(inner=outer+1;inner<nElems;inner++){
                if(arr[min]>arr[inner]){
                    min = inner;
                }
            }//每次循环完后，min指向的是剩下元素中最小的元素

            //找到最小元素后，和outer交换位置
            long temp = arr[outer];
            arr[outer] = arr[min];
            arr[min] = temp;
        }
    }
}

插入排序

乱七八糟的描述

数组：arr
两个指针：inner、outer。
一个变量（与数组内元素类型保持一致）：temp。
初始：outer和inner指向第二个位置。

取出inner所指的元素，赋给temp。
比较inner前面一位的元素与temp的大小，如果比temp小，就不动；如果比temp大，就把它向后移动一位（移到inner所指位置）。
inner向前移一位，重复操作，直到inner指向第二个元素（并进行了上述操作）。
outer向后移一位，重复上述操作，直到outer移动到最后一位（并进行了上述操作）。

图解

在这里插入图片描述

package demo;

public class InsertSort {
    public static void main(String[] args) {
        ArrayClassInsert arrayClassInsert = new ArrayClassInsert(100);
        arrayClassInsert.insert(11);
        arrayClassInsert.insert(23);
        arrayClassInsert.insert(45);
        arrayClassInsert.insert(21);
        arrayClassInsert.insert(66);
        arrayClassInsert.insert(77);
        arrayClassInsert.insert(66);
        arrayClassInsert.insert(1);

        arrayClassInsert.display();

        arrayClassInsert.insertSort();

        arrayClassInsert.display();
    }
}

/**
 * 创建一个封装数组的类
 */

class ArrayClassInsert {
    private long[] arr; //被封装的数组
    private int nElems; //数组中存在的元素的个数，当前的数组长度

    //通过类的构造方法初始化
    public ArrayClassInsert(int maxSize) { //数组的最大长度
        arr = new long[maxSize]; //初始化被封装的数组
        nElems = 0;
    }

    //新增数据项，数组元素
    public void insert(long data) {
        arr[nElems] = data;
        nElems++;
    }

    //查找某一特定的数据项
    //找到返回true，否则返回false
    public boolean find(long searchData) {
        int i;
        for (i = 0; i < nElems; i++) {
            if (searchData == arr[i]) {
                break;//找到了就直接终止循环，此时i不再++，就等于对应元素的索引值
            }
        }
        if (i == nElems) {
            return false;
        } else {
            return true;
        }
    }

    //删除指定的数据项
    public void delete(long targetDate) {
        //首先找到要删除的数据
        int i;
        for (i = 0; i < nElems; i++) {
            if (targetDate == arr[i]) {
                break;//找到了就直接终止循环，此时i不再++，就等于对应元素的索引值
            }
        }
        if (i == nElems) {
            System.out.println("没有找到要删除的数据");
        } else {
            for (int j = i; j < nElems; j++) {
                arr[j] = arr[j + 1]; //删除数组中要删除的元素
            }
            nElems--; //数组长度-1
        }
    }

    //遍历数据结构中的各个数据项
    public void display() {
        for (int i = 0; i < nElems; i++) {
            System.out.print(arr[i] + "  ");
        }
        System.out.println();//加一个换行符
    }

    /**
     * 实现插入排序，从小到大
     */
    public void insertSort(){
        int outer;
        int inner;
        long temp;

        for(outer=1;outer<nElems;outer++){
            inner = outer;
            temp = arr[outer];

            while(inner>0 && arr[inner-1]>temp){
                arr[inner] = arr[inner-1];
                inner--;
            }

            //把开始拿走的数据插回来
            arr[inner] = temp;
        }
    }

}

算法效率

效率比较

冒泡排序 < 选择排序 < 插入排序

时间复杂度

冒泡算法:严格的O(N2)
选择排序：严格的O(N2)
插入排序：O(N)~O(N2) 之间 【若是一个已经排好序的数据列表，那么只需要两个相邻的数据进行比较，并不需要交换，所以复杂度为O(N)，若是一个完全逆序的数据列表，那么每个位置的数据都需要和前面的全部数逐个进行交换，因此复杂度为O(N2) 】

Mr. Wanderer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构与算法排序之----------------选择排序
水利万物而不争
05-15 2930
选择排序改进了冒泡排序，将必要的交换次数从O(N^2)减少到O(N)。不幸的是比较次数仍然保持为O(N^2)。然而，选择排序仍然为大记录量的排序提出了一个非常重要的改进，因为这些大量的记录需要在内存中移动，这就使交换的时间和比较的时间相比起来，交换时间更为重要。（一般来说，在Java语言中不是这种情况，Java中只是改变了引用位置，而实际对象的位置并没有发生改变。） 用选择排序算法对棒...
Java数据结构和算法：冒泡、选择、插入排序算法
颠沛的小丸子
07-10 208
冒泡排序：规则就是前后比较，找到最大的放在最右端，然后依次循环比较。。。。其中需要两个循环来完成该任务，外层循环标记比较的趟数，内层循环标识每一趟需要交换元素的下标。关键需要设置一个标识位，用来标识在某一趟中，是否有交换，如果没有交换，说明已经排好序了，就可以直接停止遍历循环比较了。 public class BubbleSort { public static int[] sort...
Mysql数据库Oracle数据库正则表达式提取字符串提取中文汉字部分
m0_54625110的博客
07-25 2928
代码】Mysql数据库Oracle数据库正则表达式提取字符串提取中文汉字部分。
oracle只提取汉字,ORACLE提取字符串中"漢字"串的解決辦法
weixin_36208880的博客
04-03 1382
我在在實際工作中常常要使用去特殊字符的功能，特別是插入到數據庫中的數據，我們為了保證數據的質量，往往需要對數據進行清洗，就是去掉特殊字符，我們處理問題的思路是：判斷字符串中的每個字符是不是中文，如果是中文，將他們按照順序連接起來，如果不是，不要。根據實際業務需求，共有2中解決方案：方案一：使用數據庫自帶函數length,lengthb。中文下length返回的是字符個數，中文占1字符，length...
Sequelize 大于_输入一个不大于五位的正整数，输出对应位数的数字和逆序的数字...
weixin_39863741的博客
10-21 132
输入一个不大于五位的正整数，输出对应位数的数字和逆序的数字#include<stdio.h>void main(){int x;printf("请您输入一个不大于五位的正整数x:");scanf("%d",&x);if(x>=0){if(x<10){printf("一位整数n");printf("各位对应的数字=%dn",x);printf("逆序后的数字=%dnn...
Oracle数据截取文字中的数字部分
weixin_42599558的博客
01-11 1355
在 Oracle 中，可以使用正则表达式函数 REGEXP_SUBSTR 来截取文本中的数字部分。具体语法为： REGEXP_SUBSTR(source_string, '[[:digit:]]+', start_position, occurrence, options, match_parameter) ...
排序算法介绍——冒泡排序+插入排序+选择排序
12-21
冒泡排序相邻元素两两进行比较，每次比较结束都得到数组中最大的元素#冒泡排序def bubblesort(bubbleList): #外层循环，整个数组的长度 flag = True n = len(bubbleList) while(n): #内层循环，相邻两个数之间进行...
数据结构与算法 排序（冒泡，选择，插入）
08-29
主要介绍了数据结构与算法 排序（冒泡，选择，插入）的相关资料,这里对冒泡，选择和插入都做有实例，需要的朋友可以参考下
Java数据结构及算法实例：冒泡排序 Bubble Sort
09-03
冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换，也就是说该数列已经排序完成...
oracle提取字段中的数字
weixin_40841731的博客
02-13 3857
oracle提取字段中的数字 regexp_replace
oracle直截取汉字,ORACLE_从字符串中提取汉字（不包括全角符及日文韩文等字符） | 学步园...
weixin_36448083的博客
04-11 2415
转载自：http://blog.csdn.net/atgc/article/details/2036799感谢网友ATGC ，这个问题研究了一天，终于搞定！！从表里提取汉字, 需要考虑字符集, 不同的字符集汉字的编码有所不同这里以GB2312为例, 写一函数准确地从表里提取简体汉字.假设数据库字符集编码是GB2312, 环境变量(注册表或其它)的字符集也是GB2312编码并且保存到表里的汉字也都是...
orace 截取指定字符串前面的数字
kfzx3427的博客
03-14 1901
select replace(regexp_substr('速率100M','[0-9]+M'),'M','') speed from dual;
oracle字符串只截取中文,Oracle提取字符串中“汉字”串的解决办法
weixin_36247139的博客
04-03 2991
我们在实际工作中常常要使用去特殊字符的功能，特别是插入到数据库中的数据，我们为了保证数据的质量，往往需要对数据进行清洗，我们在实际工作中常常要使用去特殊字符的功能，特别是插入到数据库中的数据，我们为了保证数据的质量，往往需要对数据进行清洗，就是去掉特殊字符，我们处理问题的思路是：判断字符串中的每个字符是不是中文，如果是中文，将他们按照顺序连接起来，如果不是，不要。根据实际业务需求，共有2中解决方案...
oracle 截取字符串中间_截取oracle字符串中的数字
weixin_33478314的博客
01-28 1682
方法一：如果Oracle版本不是太低的话，使用 正则表达式函数 REGEXP_SUBSTR 处理。REGEXP_SUBSTR有5个参数，分别是：第一个是输入的字符串第二个是正则表达式第三个是标识从第几个字符开始正则表达式匹配。(默认为1)第四个是标识第几个匹配组。(默认为1)第五个是是取值范围：i：大小写不敏感；c：大小写敏感；n：点号 . 不匹配换行符号；m：多行模式；x：扩展模式，忽略正则表达...
oracle 取数字中文,SQL Server 提取数字、提取英文、提取中文的sql语句
weixin_42515990的博客
04-05 292
--SQL 判断字段值是否有中文create function fun_getCN(@str nvarchar(4000))returns nvarchar(4000)asbegindeclare @word nchar(1),@CN nvarchar(4000)set @CN=''while len(@str)>0beginset @word=left(@str,1)if unicode(...
oracle 匹配汉字数字,在oracle数据库中一字段存在汉字和数字，取数字部分
weixin_31309557的博客
04-03 1113
方法一：regexp_replaceselect t.achive_name,regexp_replace(t.achive_name,‘[^0-9]‘) from T_ARCHIVE_CONTENT t where t.plan_id=‘402881ef5f702d62015f7128f2760089‘;标签：regexp_replace 正则 函数的参数说明：一共6个参数，分别是1、待匹配的字...
oracle字段中摘取中文
xiao__1的博客
10-27 4029
使用正则表达式 代码: select regexp_substr('Hello,大家好！greeting', '[' || unistr('\0391') || '-' || unistr('\9fa5') || ']+') from dual;
Java实现常见排序算法总结
最新发布
05-02
除了直接插入排序外，还有许多其他常见的排序算法，如冒泡排序、选择排序、快速排序等。每种排序算法都有其适用的场景和优势，理解和掌握这些排序算法对于提高程序的执行效率和优化算法性能是非常重要的。 总的来说...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值