4、冒泡排序和稀疏数组

已于 2022-05-18 11:11:07 修改
阅读量277 收藏
点赞数
分类专栏： # 数组部分 文章标签： 排序算法 java 算法
于 2021-12-22 16:50:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/okmacong/article/details/122081555
版权

1、冒泡排序。

package com.Macong.array;

import java.util.Arrays;

public class ArrayDemo_05 {
    //冒泡排序,从小到大。

    /*
    思路一：冒泡排序把大的数通过两两比较，往后移动，直到最大的数出现在最后的位置。i为轮数，j为每轮比较的次数。
    1、n个数，第一轮，两两比较n-1次。
    2、n个数应该进行n-1轮比较，也就是length-1次。
    3、每一轮的比较次数为length-i次，如果arrays[j]大于arrays[j + 1]。那么换位，把大的往后拿。
     */

    /*
    思路二：
    1、比较数组中，两个相邻的元素，如果第一个数比第二个大，我们就交换他的位置
    2、每次比较，都会产生出一个最大的或者最小的数字。
    3、下一轮则可以少一次排序。
    4、依次循环，直到结束。
     */

    public static int[] sortArrays(int[] arrays) {


        int temp = 0;
       

        //外层循环，判断要进行多少轮比较。
        for (int i = 0; i < arrays.length - 1; i++) {
         boolean flag = false;//通过flag标识位较少没有意义的比较。
            //内层循环，比较判断两个数，如果前一个比后一个大，交换位置。
            for (int j = 0; j < arrays.length - 1 - i; j++) {

                if (arrays[j] > arrays[j + 1]) {
                    temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;
                    flag = true;

                }
            }
            //没有进行任何比较，说明已经有序了。
            if (flag == false) {
                break;
            }
        }


        return arrays;
    }


    public static void main(String[] args) {
        int[] arrays = {1, 9, 9, 5, 0, 8, 0, 6, 3, 2, 7, 1};
        //排序过的数组如下。
        System.out.println(Arrays.toString(sortArrays(arrays)));


    }
}

2、稀疏数组

原来的数组创建及打印

//创建一个二维数组，11*11   0没有棋子。1：黑棋。2：白棋。


        int[][] arrays = new int[11][11];
        arrays[1][2] = 1;//2行3列放黑棋
        arrays[2][3] = 2;//3行4列放白棋

        System.out.println("输出原始的数组：");
       // System.out.println(Arrays.toString(arrays));
        //数组名字.for。跳出增强的for


        //先按照行来取一维数组的名字，再将每个一维数组遍历。看成数组的嵌套。
        for (int[] array : arrays) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }

计算有效值个数

System.out.println("===============================================");
        //转换为稀疏数组保存。
        //获取有效值的个数。
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays[i][j]!=0)
                {

                    sum++;
                }

            }
        }
        System.out.println("有效值个数为："+sum);

矩阵稀疏操作及打印

 int[][] array_01 = new int[sum+1][3];

        array_01[0][0]=11;//行的范围
        array_01[0][1]=11;//列的范围
        array_01[0][2]=sum;//有效数字个数

        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays[i][j]!=0)
                {
                    count++;
                    array_01[count][0]=i;
                    array_01[count][1]=j;
                    array_01[count][2]=arrays[i][j];

                }

            }
        }



        System.out.println("稀疏过后的矩阵：");
        for (int[] array : array_01) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }


        System.out.println("===============================================");

矩阵的还原及打印

 System.out.println("稀疏数组还原。");
        int[][] arrays_2 = new int[array_01[0][0]][array_01[0][1]];

        int column = 0;//列
        int row = 0;//行
        int value = 0;//值
        int j=0;

        for (int i = 1; i <= array_01[0][2]; i++) {



                row = array_01[i][j];
                j++;
                column = array_01[i][j];
                j++;
                arrays_2[row][column]=array_01[i][j];
                j =0;
            }

        System.out.println("===============================================");

        System.out.println("还原的矩阵：");
        for (int[] array : arrays_2) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }

完整代码

package com.Macong.array;

import java.util.Arrays;

public class ArrayDemo_06 {
    public static void main(String[] args) {
//创建一个二维数组，11*11   0没有棋子。1：黑棋。2：白棋。


        int[][] arrays = new int[11][11];
        arrays[1][2] = 1;//2行3列放黑棋
        arrays[2][3] = 2;//3行4列放白棋

        System.out.println("输出原始的数组：");
       // System.out.println(Arrays.toString(arrays));
        //数组名字.for。跳出增强的for


        //先按照行来取一维数组的名字，再将每个一维数组遍历。看成数组的嵌套。
        for (int[] array : arrays) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }


        System.out.println("===============================================");
        //转换为稀疏数组保存。
        //获取有效值的个数。
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays[i][j]!=0)
                {

                    sum++;
                }

            }
        }
        System.out.println("有效值个数为："+sum);

        System.out.println("===============================================");

        int[][] array_01 = new int[sum+1][3];

        array_01[0][0]=11;//行的范围
        array_01[0][1]=11;//列的范围
        array_01[0][2]=sum;//有效数字个数

        int count = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (arrays[i][j]!=0)
                {
                    count++;
                    array_01[count][0]=i;
                    array_01[count][1]=j;
                    array_01[count][2]=arrays[i][j];

                }

            }
        }



        System.out.println("稀疏过后的矩阵：");
        for (int[] array : array_01) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }


        System.out.println("===============================================");

        System.out.println("稀疏数组还原。");
        int[][] arrays_2 = new int[array_01[0][0]][array_01[0][1]];

        int column = 0;//列
        int row = 0;//行
        int value = 0;//值
        int j=0;

        for (int i = 1; i <= array_01[0][2]; i++) {



                row = array_01[i][j];
                j++;
                column = array_01[i][j];
                j++;
                arrays_2[row][column]=array_01[i][j];
                j =0;
            }

        System.out.println("===============================================");

        System.out.println("还原的矩阵：");
        for (int[] array : arrays_2) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }



    }
    }

结果展示

在这里插入图片描述

okmacong
关注
专栏目录
冒泡排序和稀疏数组
qq_40031999的博客
09-30 95
冒泡排序、稀疏数组
java冒泡排序和稀疏数组
qq_42682745的博客
11-06 128
冒泡排序、稀疏数组 1.冒泡排序 两层循环，外层记录冒泡轮数，里层依次比较 时间复杂度：O(n^2) 步骤：（以升序为例） 比较数组中两个相邻的元素，第一个数比第二个数大，则交换位置，依次类推完成一轮冒泡（第一轮找到了最大值，放到了数组末尾，类推） 下一轮可以减少一次排序比较，因为上一轮已经确定了一个最大值，下一轮就应该除去这个数，以求剩余数的最大值，所以里层循环次数应该减去已经排好的数的个数（简单一点就是里层循环次数=数组长度-外层循环次数） 依次循环，直到结束。 import java.util.A
数组05：冒泡排序和稀疏数组
weixin_47558943的博客
02-11 839
冒泡排序 1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置。 2.每一次比较，都会产生出一个最大、或者最小的数字； 3.下一轮则可以少一次排序！ 4.依次循环，直到结束。 优化的方法： 1.加flag 如何交换值？ 进行交换，同时PressOn的折线变直线，如下图所示。 package com.xiyue.array; import java.util.Arrays; public class ArrayDemo08 { public static void main
冒泡排序及稀疏数组
H1402371150的博客
02-24 101
冒泡排序 package Array; //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置 //2.每一次比较，都会产生出一个最大，或者最小的数字； //3.下一轮则可以减少一次排序！ //4.一次循环，直到结束！ import java.util.Arrays; public class ArrayDemo07 { public static void main(String[] args) { int[] a = {12,3,456,8,4
java中Arrays类，冒泡排序和稀疏数组
qq_52332852的博客
02-16 469
Arrays类 数组的工具类：java.util.Arrays Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用对象来调用。 具有以下常用功能： 给数组赋值：通过fill方法 对数组排序：sort方法 比较数组：equals方法比较元素值是否相等 查找数组元素：通过binarySearch方法堆排序好的数组进行二分查找法操作。 例题：用方法输出数组和直接输出数组 import java.util.Arrays; public class ArraryDemo
Java——冒泡排序和稀疏数组
qq_54641369的博客
09-05 75
一、冒泡排序 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序 冒泡的代码还是相当简单，两层循环，外层泡轮数，里层一次比较 我们看到嵌套循环，立马得出这个算法的时间复杂度为O（n2） 四个步骤 两个循环，外层循环计算比较次数 内层循环比较两个相邻的元素，如果第一个数比第二个数大，则交换位置**(每次都找出了最大的数字)** 下一轮则可以少一次排序 依次循环，直至结束 public static int[] sort1(int[] a ){ for (int i = 0;i&lt
javaSE冒泡排序、稀疏数组
qiminyuan的博客
04-15 59
当数组中大部分元素为0，，或者为同一值的数组时，可用稀疏数组来保存该数组。两层循环，外层冒泡轮数，里层依次比较。
java数组 冒泡排序及稀疏数组
Coision_hl的博客
07-06 111
java数组基础 冒泡排序以及稀疏数组
狂神Java之冒泡排序、稀疏数组
m0_57968888的博客
02-28 90
冒泡排序的代码，两层循环，外层冒泡轮数，里层依次比较 它的时间复杂度O（n2） 比如上述数组是一个6行七列的，其中有效的数值只有8个，行旁边的1~8是记录这些有效数字的具体位置比如第0行3列值就是22。 package com.kuang.array; import java.sql.SQLOutput; public class ArrayDemo08 { public static void main(String[] args) { //创...
数组的Arrays类，冒泡排序，稀疏数组
qq_51993933的博客
03-02 101
Arrays类 数组的工具类java.util.Arrays 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作 查看JDK帮助文档 Arrays类中的方法都是static修饰的静态方法，在使用的时候来调用(注意：是“不用”而不是“不能”) 具有以下常用功能： 给数组赋值：通过fill方法 对数组排序：通过sort方法，按升序 比较数组：通过equals方法比较数组中元素值是否相等 查找数组元素：通过binarySearch
Arrays类数组 冒泡排序 稀疏矩阵
weixin_42941348的博客
01-22 139
Arrays类数组 int[] a={1,2,3,4,5,999,887,6,5}; //sout（a）； //打印数组元素 Arrays.toString(a); //把a数组打印出来。 //排序 Arrays.sort(a);//数组进行排序,升序 System.out.println(Arrays.toString(a)); 比较数组：通过equals方法比较数组中元素值是否相等。 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作 数组填充 //
Java中的多维数组(冒泡排序,Arrays类的使用)及稀疏数组笔记(2022.4.19)
weixin_66262328的博客
04-19 622
多维数组 多维数组可以看成是数组的的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。 二维数组 int a[][] = new int[2][5]; 解析：以上二维数组a可以看成一个两行五列的数组。 二维数组使用1： package com.zhai.array; public class Arrays1 { //二维数组 public static void main(String[] args) { /
Java数组最详解（包含数组的概述，声明创建，使用，多维数组，Arrays类，稀疏数组）
m0_68811665的博客
04-09 410
数组 数组的定义 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成。 其中，每一个数据称为一个数组的元素，每个数组元素可以通过一个下标来访问它们。 数组的声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法： dataType[] arrayRefVar; //首选方法 ​ dataType arrayRefVar; //效果相同，但不是首选方法 java语言使用new操作符来创建
冒泡排序（Bubble Sort）含gif动图
kir_77的博客
11-30 6525
一、什么是冒泡排序 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。 二、冒泡排序算法的思想 我们从左边开始把相邻的两
前端五种排序
everyStudy的博客
09-20 381
【代码】前端五种排序。
C++学习笔记（35）
qq_60098634的博客
09-20 550
// 判断链表是否存在。} // 判断链表是否存在。
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 94
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java Stream流编程入门
2301_77207909的博客
09-21 551
Java StreamAPI的使用与常用方法
C语言程序设计：稀疏多项式运算与成绩排序算法
3. 冒泡排序：遍历成绩数组，多次交换相邻元素，如果平均成绩高则后移，实现非递增排序。 4. 选择排序：从数组中选取最小元素（平均成绩低）放到正确位置，重复此过程，实现非递增排序。 5. 单链表排序：将所有班级...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值