数组之动态初始化,栈堆内存图,反转元素,sort排序,冒泡排序和稀疏数组

数组 动态初始化包含了默认初始化 array[]是早期为了迎合c语言和c++用户

int array[] = new int[10];

double[] nums = new double[5];
System.out.println(nums[4]);//0.0

//静态初始化
Demo01[] demo01s = {new Demo01(),new Demo01()};

---

底层原理:数组的栈堆内存图 数组本身就是对象,元素相当于成员变量

不要做越界的事情,学以致用

反转数组元素

int[] array = {1,2,3,4,5};


int[] reverse = new int[array.length];
for (int i = 0, j = reverse.length - 1; i < array.length; i++,j--) {
    reverse[i] = array[j];
}

---

不要重复造轮子 自己实现Arrays.toString方法

public static void printArray(int[] array){
    for (int i = 0; i < array.length; i++) {
        if(i == 0){
            System.out.print("[");
        }

        if(i == array.length - 1){
            System.out.print(array[i] + "]");
            return;
        }

        System.out.print(array[i] + ", ");

    }
}

sort排序:时间复杂度为O(n的2次方)

int[] array = {1,2343,5,54,65};

Arrays.sort(array);
System.out.println(Arrays.toString(array));

fill填充替换

Arrays.fill(array,2,4,0);

---

冒泡排序

public static void main(String[] args) {
    double[] array = new double[]{45, 65,888, 89,1000,100.5, 32};

    array = bubble(array);
    System.out.println(Arrays.toString(array));
}

public static double[] bubble(double[] array){

    
    for (int i = 0; i < array.length - 1; i++) {
        boolean flag = true;
        for (int j = 0; j < array.length - 1 - i; j++) {
            if(array[j] < array[j+1]){
                double temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;

                flag = false;
            }
        }

        if(flag){
            break;
        }

    }

    return array;
}

---

稀疏数组 稀疏数组只记录有效数据

一个10行10列的棋盘,只有第二行第三列和第三行第四列有效实现这个棋盘变成稀疏数组再还原

int[][] arrays = new int[10][10];
arrays[1][2] = 1;
arrays[2][3] = 2;
arrays[5][3] = 1;

//sum记录所有有效数字的个数
int sum = 0;
for(int[] array:arrays){
    for(int value:array){
        System.out.print(value + "t");
        if(value != 0){
            sum++;
        }
    }
    System.out.println();
}

稀疏数组也是一个二维数组,也有行和列

第一行记录所有行,列和有效数字个数往后记录有效数字的位置和值

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

sparse[0][0] = arrays.length;
sparse[0][1] = arrays[0].length;
sparse[0][2] = sum;

int index = 1;
for (int i = 0; i < arrays.length; i++) {
    for (int j = 0; j < arrays[i].length; j++) {
        if(arrays[i][j] != 0){
            
            sparse[index][0] = i;
            sparse[index][1] = j;
            sparse[index][2] = arrays[i][j];
            index++;
        }
    }
}
System.out.println("稀疏数组:");
for(int[] array:sparse){
    for(int value:array){
        System.out.print(value + "t");
    }
    System.out.println();
}

稀疏数组还原 第一种方法

一个新的二维数组,长度就是稀疏数组中记录的原数组的行和列遍历稀疏数组:新数组对应位置上的值,就是稀疏数组中记录的值

int[][] oldArray = new int[sparse[0][0]][sparse[0][1]];

for (int i = 1; i < sparse.length; i++) {
    
    oldArray[sparse[i][0]][sparse[i][1]] = sparse[i][2];
}

for(int[] array:oldArray){
    for(int value:array){
        System.out.print(value + "t");
    }
    System.out.println();
}

第二种方法:直接打印

用稀疏数组存储的行,列来作为"无效数字"的for循环遍历从1开始遍历稀疏数组索引到达稀疏数组中记录的值时打印

System.out.println("还原:");
for (int j = 0; j < sparse[0][0]; j++) {
    for (int k = 0; k < sparse[0][1]; k++) {

        
        for (int i = 1; i < sparse.length; i++) {

            if(j == sparse[i][0] && k == sparse[i][1]){
                System.out.print(sparse[i][2] + "t");
                k++;
            }

        }

        System.out.print("0t");

    }
    System.out.println();
}

---

思考:有没有必要注意不能超出稀疏数组记录的有效值个数

= 稀疏数组记录有效数字时多了或者少了答:稀疏数组已经记录了行和列实践后(增加或减少有效数字个数后,程序没有出错).只要遍历原数组时不出错这里就不会出错