数据结构 -- 数组的学习

数据结构 -- 数组的学习

　　　　

　　　　数组学习目录

　　　　　　1、数组基本知识

　　　　　　　   2、二维矩阵相加

　　　　　　　   3、二维转置矩阵

　　　　　　　   4、二维稀疏矩阵（矩阵转换为三项式、三项式转换为矩阵）

　　　　　　　   5、数组与多项式

 

　　　　1、数组的基本知识

　　　　　　数组是一个特殊的数据结构，一旦给定了数组的维数 n 及各维长度 b 则该数组中存放的数据的个数就是确定的，数组的基本操作不涉及数组结构的变化，因此对于数组而言，采用顺序存储表示比较合适。

　　　　　　数组的主要操作：1、就是对数组中的特定位置的值进行获取  2、就是对数组中的特定位置的值进行修改

　　　　　　数组的顺序存储结构有两种：1、按行存储  2、就是按列存储   （二维数组主要就是按行存储）

　　　　　　数组的地址计算：

　　　　　　一维数组：a1、a2、a3、a4...    size即是每一个元素所占的字节空间。

　　　　　　　　　　    Loc(ai) = Loc(1) + (i - 1) * size

　　　　　　二维数组：以二维数组 A m*n 的二维数组为例，假设每一个元素只占一个存储空间，并且是按行存储的，数组的下标是从1开始，则首元素为Loc(A[1][1]) ，而A[i][j] 这个元素，前面有（i - 1）行，在第i行，j列的前面有（j - 1）个元素，则

　　　　　　　　　　   Loc(A[i][j]) = Loc(A[1][1]) + (n * (i - 1) + j - 1) * size

　　　　　　例如：已知二维数组A[5][4]按行序为主序存放，每个元素占4个字节的存储空间，计算：

　　　　　　　　    1、计算数组A中的元素的个数？   答案： 5 * 4 = 20

　　　　　　　　　 2、若数组A的首元素A[1][1]的地址为2000，计算A[3][2]的内存空间。

　　　　　　　　　　   Loc(A[3][2]) = 2000 + (4 * (3 - 1)  + 2 - 1) * 4 = 2036

 

　　　　2、二维矩阵相加

　　　　　　二维矩阵的相加，就是两个二维矩阵之间各个位置对应起来，进行相加。

　　　　　　算法代码：

/**
 * 二维矩阵相加
 */
public class Demone1 {
    public static void main(String[] args) {
        // 初始化
        int[][] array1 = new int[4][4];
        int[][] array2 = new int[4][4];
        int index = 1;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                array1[i][j] = index;
                array2[i][j] = index;
                index++;
            }
        }
        twoDimensional(array1,array2);
    }

    private static void twoDimensional(int[][] array1, int[][] array2) {

        int[][] sum = new int[array1.length][array1[0].length];
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[0].length; j++) {
                sum[i][j] = array1[i][j] + array2[i][j];
            }
        }
        printArray(sum);
    }

    private static void printArray(int[][] sum) {
        for (int i = 0; i < sum.length; i++) {
            for (int j = 0; j < sum[0].length; j++) {
                System.out.print(sum[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

　　　　　　算法结果：

　　　　　　二维矩阵的相称也是同理。

 

　　　　3、二维转置矩阵

　　　　　　二维数组的转置，可以随意转动，这里我的例子会是：将数组顺时针旋转90度。

　　　　　　算法代码：

/**
 * 二维矩阵转置
 */
public class Demone3 {
    public static void main(String[] args) {
        // 初始化
        int[][] array = new int[4][4];
        int index = 1;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                array[i][j] = index;
                index++;
            }
        }
        Transpose(array);
        System.out.println("原二维矩阵：");
        printArray(array);
    }

    private static void Transpose(int[][] array) {
        int[][] newArray = new int[array.length][array[0].length];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[0].length; j++) {
                newArray[i][j] = array[j][i];
            }
        }
        System.out.println("现二维矩阵：");
        printArray(newArray);
    }
    private static void printArray(int[][] sum) {
        for (int i = 0; i < sum.length; i++) {
            for (int j = 0; j < sum[0].length; j++) {
                System.out.print(sum[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

　　　　算法结果：

 

 

 

　　　　4、二维稀疏矩阵（矩阵压缩为三项式、三项式还原为矩阵）

　　　　　  1、矩阵压缩为三项式

　　　　　　

/**
 * 稀疏二维矩阵（矩阵转三项式、三项式转二维矩阵）
 */
public class Demone4 {
    public static void main(String[] args) {
        int[][] arrary = new int[10][10];
        for (int i = 0; i < arrary.length; i++) {
            for (int j = 0; j < arrary[0].length; j++) {
                arrary[i][j] = 0;
            }
        }
        arrary[5][6] = 78;
        arrary[1][3] = 10;
        arrary[0][7] = 56;
        arrary[2][3] = 7;
        arrary[2][9] = 99;
        arrary[7][6] = 4;
        arrary[2][2] = 20;
        arrary[8][3] = 19;
        yasuo(arrary);
    }

    private static void yasuo(int[][] arrary) {
        int sum = 0;
        for (int i = 0; i < arrary.length; i++) {
            for (int j = 0; j < arrary[0].length; j++) {
                if (arrary[i][j] != 0) {
                    sum++;
                }
            }
        }
        int[][] yasuo = new int[sum + 1][3];
        yasuo[0][0] = arrary.length;
        yasuo[0][1] = arrary[0].length;
        yasuo[0][2] = sum;
        int temp = 1;
        for (int i = 0; i < arrary.length; i++) {
            for (int j = 0; j < arrary[0].length; j++) {
                if (arrary[i][j] != 0) {
                    yasuo[temp][0] = i;
                    yasuo[temp][1] = j;
                    yasuo[temp][2] = arrary[i][j];
                    temp++;
                }
            }
        }

        printArray(yasuo);
    }

    public static void printArray(int[][] sum) {
        for (int i = 0; i < sum.length; i++) {
            for (int j = 0; j < sum[0].length; j++) {
                System.out.print(sum[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

　　　　算法结果：

　　　　　  2、三项式还原为矩阵

　　　　　　

/**
 * 稀疏二维矩阵（矩阵转三项式、三项式转二维矩阵）
 */
public class Demone2 {
    public static void main(String[] args) {
        int[][] compress = new int[9][3];
        compress[0][0] = 8;compress[0][1] = 9;compress[0][2] = 8;
        compress[1][0] = 0;compress[1][1] = 1;compress[1][2] = 4;
        compress[2][0] = 0;compress[2][1] = 4;compress[2][2] = 3;
        compress[3][0] = 0;compress[3][1] = 7;compress[3][2] = 1;
        compress[4][0] = 2;compress[4][1] = 6;compress[4][2] = 5;
        compress[5][0] = 3;compress[5][1] = 5;compress[5][2] = 6;
        compress[6][0] = 4;compress[6][1] = 2;compress[6][2] = 8;
        compress[7][0] = 5;compress[7][1] = 8;compress[7][2] = 2;
        compress[8][0] = 6;compress[8][1] = 7;compress[8][2] = 9;
        huanyuan(compress);
    }

    private static void huanyuan(int[][] compress) {
        int row = compress[0][0];
        int col = compress[0][1];
        int[][] arrary = new int[row][col];
        for (int i = 1; i <= row; i++) {
            int temp1 = compress[i][0];
            int temp2 = compress[i][1];
            int temp3 = compress[i][2];
            arrary[temp1][temp2] = temp3;
        }
        printArray(arrary);
    }

    private static void printArray(int[][] sum) {
        for (int i = 0; i < sum.length; i++) {
            for (int j = 0; j < sum[0].length; j++) {
                System.out.print(sum[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

　　　　算法结果：

 

 

　　　　5、数组与多项式