数组之动态初始化,栈堆内存图,反转元素,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){

    /**
     * i < array.length -1:5个数字只用比较4轮
     * j < array.length - 1 - i:第三轮比较时,前两个数字已经排序好了
     *
     * if(flag):元素数据不用改变,就代表已经全部排序好了.
     */
    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列的棋盘,只有第二行第三列和第三行第四列有效
• 实现这个棋盘
• 变成稀疏数组
• 再还原

/**
* 一个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++) {

        /**
         * 遍历稀疏数组,等于值就打印
         * 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("0\t");

    }
    System.out.println();
}

---

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

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