• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

Java数组(概念,冒泡,稀疏)

开发技术 开发技术 4小时前 1次浏览

Java数组

  • 数组是相同类型的数据的有序集合,但可以是任意类型包括基本数据类型和引用类型.
  • 长度是确定的,一旦创建不可改变
  • 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成
  • 每一个数组称作一个数组元素,每个数组元素都可以通过一个下标来访问.
  • 数组的变量属于应用类型,数组可以看成是对象,每个元素相当于成员变量,
  • 数组对象本身是在堆中
//定义方式
int[] nums;//建议使用这种声明一个数组
int nums2[];
//创建一个数组
nums = new int[10];//创建时需要长度
//可以写一起
int[] nums = new int[10]

三种初始化

静态初始化

创建加赋值

int[] s = {1,2,3};

动态初始化

其中分配空间的值设为该类型的默认值

int[] b = new int[10];

经典冒泡

//冒泡排序,前后相邻的两数挨个比较,小的放前面一位
public static int[] sort(int[] array){
    //长度-1,因为最后一位不用排
    for (int i = 0; i < array.length-1; i++) {
        int temp = 0;
        //下表不能超过i
        for (int j = 0; j < array.length-1-i; j++) {
            if(array[j]>array[j+1]){
                temp = array[j];
                array[j] = array[j+1];
                array[j+1]=temp;
            }
        }
    }
    return array;
}

稀疏数组

  • 当一个数组中大部分元素为0,或者为同一值的数组时,可以使用
  • 处理方法: 记录一共有几行几列,有多少不同值 ; 把具有不同值的元素和行列及值记录在一个小数组,从而缩小规模

例:::

public static void sparseSmall(){
    //创建一个需要压缩的数组
    int [][] array1 = new int[5][5];
    array1[1][2] = 1;
    array1[3][2] = 1;
    array1[2][4] = 2;
    array1[2][3] = 2;
    for (int[] arr1 : array1) {
        for (int i : arr1) {
            System.out.print(i + "t");
        }
        System.out.println();
    }
    System.out.println("=============================");
    //找到不同值的个数
    int sum = 0;
    for (int[] ints : array1) {
        for (int j = 0; j < array1.length; j++) {
            if (ints[j] != 0) {
                sum += 1;
            }
        }
    }
    //创建一个空稀疏数组
    int[][] array2 = new int[sum + 1][3];
    array2[0][0] = array1.length;
    array2[0][1] = array1[0].length;
    array2[0][2] = sum;
    int count = 0;
    //往里注入值
    for (int i = 0; i < array1.length; i++) {
        for (int j = 0; j < array1[i].length; j++) {
            if (array1[i][j] != 0) {
                count++;
                array2[count][0]=i;
                array2[count][1]=j;
                array2[count][2]=array1[i][j];
            }
        }
    }
    //打印创建好的稀疏数组
    for (int[] arr1 : array2) {
        for (int i : arr1) {
            System.out.print(i + "t");
        }
        System.out.println();
    }
    System.out.println("=======================");

    //还原稀疏数组

    //用稀疏数组的第一行还原原数组的长和宽
    int[][] array3 = new int[array2[0][0]][array2[0][1]];
    //从稀疏数组第二行开始便利
    for (int i = 1; i < array2.length; i++) {
        //拿取稀疏数组每行的x坐标和y坐标;
        int a = array2[i][0];
        int b = array2[i][1];
        //拿去稀疏数组中存的每行不同的值;
        int c = array2[i][2];
        //将每行不同的值按照x,y坐标还原
        array3[a][b] = c;
    }

    //打印还原后的原数组,检验对错
    for (int[] arr1 : array3) {
        for (int i : arr1) {
            System.out.print(i + "t");
        }
        System.out.println();
    }
}

程序员灯塔
转载请注明原文链接:Java数组(概念,冒泡,稀疏)
喜欢 (0)