java数组.day16(冒泡排序,稀疏数组)

冒泡排序

  1. 冒泡排序无疑是最为出名的排序算法之一,总共有八大排序!

  2. 冒泡的代码还是相当简单的,两层循环,外层冒泡轮数,里层依次比较,江湖中人人尽皆知。

  3. 我们看到嵌套循环,应该立马就可以得出这个算法的时间复杂度为O(n2)。

代码示例:

复制代码
public class ArrayDemoe7 {
    public static void main(string[]args) {
        int[] a = {1,4,5,6,72,2,2,2,25,6,7};
        int[] sort = sort(a);//调用完我们自己写的排序方法以后,返回一个排序后的数组
​
    }
    public static int[]sort(int[ ]array){
        //临时变量
        int temp = 0;
        
        //外层循环,判断我们这个要走多少次;
        for (int i = 0; i < array.length-1;i++) {
        //内层循环,比价判断两个数,如果第一个数,比第二个数大,则交换位置
            for (int j = 0; j < array.length-1-i;j++) {
                if (array[j+1]>array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
        }
   }
return array;
)
​

稀疏数组

  1. 当一个数组中大部分元素为0,或者为同一值的数组时,可以使用稀疏数组来保存该数组。'

  2. 稀疏数组的处理方式是:

    1. 记录数组一共有几行几列,有多少个不同值

    2. 把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模

如下图:左边是原始数组,右边是稀疏数组

在二维数组中其中大部分都是一样的数值,但存在一小部分数值不同时,挑出不同的组成稀疏数组

例如上图中[o]排的意思是该稀疏数组记录的是具有6行7列的二维数组,其中一共有8个不同的值,下面[1],[2],[3]...代表的意思,举例[1]:第0行,第3列的值是22。

代码示例:

复制代码
public class Array {
    public static void main(String[] args) {
        //1.创建一个二维数组11* 1i0:没有棋子,1:黑棋2:白棋
        int[][]array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始的数组
        System.out.println("输出原始的数组");
    
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print( anInt+"\t" );
            }
            System.out.print1n();
        }
        //转换为稀疏数组保存
        System.out.print1n( "=====================");
//获取有效值的个数
    int sum = 0;
    for (int i = 0; i < 11; i++) {
        for (int j = 0; j < 11;j++) {
            if ( array1[i][j]!=0){
                sum++;
            }
        }
    }
    System.out. println("有效值的个数:"+sum) ;
    //2.创建一个稀疏数组的数组
    int[][]array2 = new int[sum+1][3];
    array2[0][0] = 11;//行数
    array2[0][1] = 11;//列数
    array2[0][2] = sum;//值
​
    //遍历二维数组,将非零的值,存放稀疏数组中
    int count=o;
    for (int i = e; i < array1 . length ; i++) {
        for (int j = o; j < array1[i].iength; j++) {
            if ( array1[i][j]!=o){
                count++;
                array2[count][0] = i;
                array2[count][1] = j;
                array2[countj[2] = array1[i][j];
                       }
                   }
               }
    //输出稀疏数组
        System.out.print1n("稀疏数组");
        for (int i = o; i < array2.length; i++) {
        System.out.print1n(array2[i][0]+""\t"
        +array2[i][1]+"\t”
        +array2[i][2]+"\t");
​
        }
        System. out.print1n( "=====================");
        System.out.println(“还原"");
        //1.读取稀疏数组
        int[][]array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
        array3[array2[i][0]][array2[i][1]] = array2[i][2];
        //3.打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
​
    }
}
相关推荐
卡尔特斯17 小时前
Android Kotlin 项目代理配置【详细步骤(可选)】
android·java·kotlin
白鲸开源17 小时前
Ubuntu 22 下 DolphinScheduler 3.x 伪集群部署实录
java·ubuntu·开源
ytadpole17 小时前
Java 25 新特性 更简洁、更高效、更现代
java·后端
纪莫17 小时前
A公司一面:类加载的过程是怎么样的? 双亲委派的优点和缺点? 产生fullGC的情况有哪些? spring的动态代理有哪些?区别是什么? 如何排查CPU使用率过高?
java·java面试⑧股
JavaGuide18 小时前
JDK 25(长期支持版) 发布,新特性解读!
java·后端
用户37215742613518 小时前
Java 轻松批量替换 Word 文档文字内容
java
白鲸开源18 小时前
教你数分钟内创建并运行一个 DolphinScheduler Workflow!
java
CoovallyAIHub19 小时前
中科大DSAI Lab团队多篇论文入选ICCV 2025,推动三维视觉与泛化感知技术突破
深度学习·算法·计算机视觉
Java中文社群19 小时前
有点意思!Java8后最有用新特性排行榜!
java·后端·面试
代码匠心19 小时前
从零开始学Flink:数据源
java·大数据·后端·flink