数据结构之数组结构（二）

最新推荐文章于 2024-06-21 18:00:16 发布
最新推荐文章于 2024-06-21 18:00:16 发布
阅读量477 收藏
点赞数 1
分类专栏： 数据结构（Java） 文章标签： 数据结构 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chao_le/article/details/51126116
版权

上篇文章我们对线性表和数组做个一些简单的了解。这篇我们通过代码来演示数组的使用。

数学中的矩阵（matrix）用来描述二维数组的最好方式。那么本章主要来通过代码来讨论矩阵的相加，相乘以及稀疏矩阵，转置矩阵，上三角与小三角矩阵。

矩阵相加
package arrays;

public class matrixAdd {
    /*
     * 两个矩阵相加
     * 
     */
    private static void MatrixAdd(int[][] arrayA, int[][] arrayB, int[][] arrayC, int x, int y) {
        // TODO Auto-generated method stub
        int row,col;
        if(x<=0||y<=0){
            System.out.println("矩阵维数必须大于0");
            return;
        }
        for(row=1;row<=x;row++){
            for(col=1;col<=y;col++){
                arrayC[(row-1)][(col-1)]=arrayA[(row-1)][(col-1)]+arrayB
                        [(row-1)][col-1];
            }
        }

    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int i;
        int j;
        final int ROWS=3;
        final int COLS=3;
        //定义两个数组，即矩阵
        int[][] A={{1,3,5},{7,9,11},{13,15,17}};
        int[][] B={{9,8,7},{6,5,4},{3,2,1}};
        int[][] C=new int[ROWS][COLS];
        System.out.println("[矩阵A的各个元素]");//打印矩阵A的内容
        for(i=0;i<3;i++){
            for(j=0;j<3;j++){
                System.out.print(A[i][j]+" \t");
            }
            System.out.println();
        }
        System.out.println("[矩阵B的各个元素]");//打印矩阵B的内容
        for(i=0;i<3;i++){
            for(j=0;j<3;j++){
                System.out.print(B[i][j]+"\t");
            }
            System.out.println();
        }
        MatrixAdd(A,B,C,3,3);
        System.out.println("[矩阵A和B相加的结果]");//打印矩阵C的内容
        for(i=0;i<3;i++){
            for(j=0;j<3;j++){
                System.out.print(C[i][j]+" \t");
            }
            System.out.println();
        }

    }   
}
矩阵相乘
package arrays;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class matrixMultiply {
    private static void MatrixMultiply(int[][] arrA, int[][] arrB, int[][] arrC, int m,
            int n, int p) {
        if(m<=0||n<=0||p<=0){
            System.out.println("输入错误：n，m，p必须大于0");
            return;
        }
        for(int i=0;i<m;i++){
            for(int j=0;j<p;j++){
                int  temp=0;
                for(int k=0;k<n;k++){
                    temp=temp+arrA[i][k]*arrB[k][j];
                    arrC[i][j]=temp;
                }
            }
        }
    }
    public static void main(String[] args) throws  IOException {
        int m,n,p;
        int i,j;;
        String temp;//用来接收矩阵输入的值
        BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入矩阵A的维数(m,n)");
        System.out.println("请先输入矩阵A的m值");
        m=Integer.parseInt(keyin.readLine());
        System.out.println("接下来输入矩阵A的n值");
        n=Integer.parseInt(keyin.readLine());
        int A[][]=new int[m][n];
        System.out.println("请输入矩阵A的各个元素");
        for(i=0;i<m;i++){
            for(j=0;j<n;j++){
                System.out.println("a"+i+j+"=");
                temp=keyin.readLine();
                A[i][j]=Integer.parseInt(temp);
            }
        }
        System.out.println("请输入矩阵B的维数(n,p)");
        System.out.println("请先输入矩阵B的n值");
        n=Integer.parseInt(keyin.readLine());
        System.out.println("接下来输入矩阵B的p值");
        p=Integer.parseInt(keyin.readLine());
        int B[][]=new int[n][p];
        System.out.println("请输入矩阵B的各个元素");
        for(i=0;i<n;i++){
            for(j=0;j<p;j++){
                System.out.println("b"+i+j+"=");
                temp=keyin.readLine();
                B[i][j]=Integer.parseInt(temp);
            }
        }
        int[][] C=new int[m][p];
        MatrixMultiply(A,B,C,m,n,p);
        System.out.println("A和B相乘结果为");
        for(i=0;i<m;i++){
            for(j=0;j<p;j++){
                System.out.print(C[i][j]+"\t");
            }
            System.out.println();
        }
    }
}
转置矩阵

假设A为m*n矩阵。则A的转置矩阵为n*m

package arrays;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class matrixZZ {

    public static void main(String[] args) throws  IOException {
        int m,n;
        int row,col;;
        String temp;//用来接收矩阵输入的值
        BufferedReader keyin=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入m*n矩阵的维数(m,n)");
        System.out.println("请先输入矩阵维度的m:");
        m=Integer.parseInt(keyin.readLine());
        System.out.println("接下来输入矩阵维度的n:");
        n=Integer.parseInt(keyin.readLine());
        int A[][]=new int[m][n];
        int B[][]=new int[n][m];
        System.out.println("请输入矩阵的内容");
        for(row=1;row<=m;row++){
            for(col=1;col<=n;col++){
                System.out.println("a"+row+col+"=");
                temp=keyin.readLine();
                A[row-1][col-1]=Integer.parseInt(temp);
            }
        }

        System.out.println("输入的矩阵为:");
        for(row=1;row<=m;row++){
            for(col=1;col<=n;col++){
                System.out.print(A[row-1][col-1]+"\t");

            }
            System.out.println();
        }
        //进行转置的动作
        for(row=1;row<=n;row++){
            for(col=1;col<=m;col++){
                B[(row-1)][(col-1)]=A[(col-1)][(row-1)];
            }
        }
        System.out.println("转置矩阵为:");
        for(row=1;row<=n;row++){
            for(col=1;col<=m;col++){
                System.out.print(B[row-1][col-1]+"\t");
            }
            System.out.println();
        }
    }
}
稀疏矩阵
package arrays;

import java.io.IOException;

public class SparseMatrix {
    /*
     * 稀疏矩阵:一个矩阵中大部分元素都为0，即可称为“稀疏矩阵”。如果直接使用传统的二维数组来存储，会造成
     * 内存空间大量浪费，改进的方法为三项式（3-tuple）。例如:
     *  25   0    0    32   0    -25              1    2    3                        
     *  0    33   77   0    0    0           0    6    6    6                              
     *  0    0    0    55   0    0           1    1    1    25            
     *  0    0    0    0    0    0   压缩后为:2    1    4    32         
     *  101  0    0    0    0    0           3    1    6    -25                       
     *  0    0    0    38   0    0           4    2    2    33         
     *                                       5    2    3    77
     *  A(0,1)=表示此矩阵的行数                6    3    4    55
     *  A(0,1)=表示此矩阵的列数                7    5    1    101
     *  A(0,3)=表示此矩阵的非零项目的总数。      8    6    3    38
     *  利于此三项式数据结构来压缩稀疏矩阵的方法。可以减少内存的不必要的浪费。
     */
    public static void main(String[] args) throws  IOException {
        final int ROWS=8;//定义行数
        final int COLS=9;//定义列数
        final int NOTZERO=8;//定义稀疏矩阵中不为0的数
        int i,j,rw,cl,nz;
        int temp=1;
        int[][] Sparse=new int[ROWS][COLS];//声明稀疏矩阵
        int[][] Compress=new int[NOTZERO+1][3];//声明压缩矩阵
        //将稀疏矩阵的元素全设为0
        for(i=0;i<ROWS;i++){
            for(j=0;j<COLS;j++){
                Sparse[i][j]=0;
            }
        }

        nz=NOTZERO;
        for( i=1;i<nz+1;i++){
            rw=(int) (Math.random()*100);
            rw=rw%ROWS;
            cl=(int)(Math.random()*100);
            cl=cl%COLS;
            if(Sparse[rw][cl]!=0){
                nz++;//避免同一元素设定两次数值而造成压缩矩阵中有0
            }
            Sparse[rw][cl]=i;//随机产生稀疏矩阵中非零的元素值
        }
        System.out.println("打印矩阵中的元素");
        for(i=0;i<ROWS;i++){
            for(j=0;j<COLS;j++){
                System.out.print(Sparse[i][j]+"");
            }
            System.out.println();
        }
        //开始压缩稀疏矩阵
        Compress[0][0]=ROWS;
        Compress[0][1]=COLS;
        Compress[0][2]=NOTZERO;
        for(i=0;i<ROWS;i++){
            for(j=0;j<COLS;j++){
                if(Sparse[i][j]!=0){
                    Compress[temp][0]=i;
                    Compress[temp][1]=j;
                    Compress[temp][2]=Sparse[i][j];
                    temp++;
                }
            }
        }
        System.out.println("系数矩阵压缩后的内容为:");
        for(i=0;i<NOTZERO+1;i++){
            for(j=0;j<3;j++){
                System.out.print(Compress[i][j]+" ");
            }
            System.out.println();
        }
    }
}

运行结果：

打印矩阵中的元素
000800000
000000000
000000000
002006000
000000000
100400000
000970500
000000000
系数矩阵压缩后的内容为:
8 9 8 
0 3 8 
3 2 2 
3 5 6 
5 0 1 
5 3 4 
6 3 9 
6 4 7 
6 6 5
上三角矩阵
package arrays;

public class UpperTrangularMatrix {
    /*
     * 上三角矩阵:就是一种对角线以下皆为0的n*n矩阵，其中又分为右上三角矩阵和左上三角矩阵。由于上三角
     * 矩阵仍有许多的为0，所以我们可以把三角矩阵的二维模式存储在一维数组中。共有n*(n+1)/2项
     * 也可分为“以行为主”和“以列为主”。下面以左上三角矩阵为例：
     * 求A[i][j]在数组中所对应的k值，n*n矩阵。
     * 以行为主：k=n*(i-1)-i*(i-1)/2+j;
     * 以列为主:k=j*(j-1)/2+i;
     * 假如有一个5*5的右上三角矩阵A，以列为主对应到一维数组B，请问a23所对应B(k)的k值多少？
     * k=j*(j-1)/2+i=3*(3-1)/2+2=5    a23=B(5)
     * 左上三角矩阵:
     * 求A[i][j]在数组中所对应的k值，n*n矩阵。
     * 以行为主：k=n*(i-1)-(i-2)*(i-1)/2+j;
     * 以列为主:k=n*(j-1)-(j-1)*(j-2)/2+i;
     */
    public static void main(String[] args) {
        int[][] array={{7,8,12,21,9},
                       {0,5,14,17,6},
                       {0,0,7,23,24},
                       {0,0,0,32,19},
                       {0,0,0,0,8}};
        showArray(array);
        result(array);
    }
    private static void showArray(int[][] array) {
        System.out.println("上三角矩阵");
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array.length;j++){
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }
    private static void result(int[][] array) {
        int[] arr;
        int arrSize;
        int index=0;
        arrSize=array.length;
        arr=new int[arrSize*(arrSize+1)/2];
        for(int i=0;i<arrSize;i++){
            for(int j=0;j<arrSize;j++){
                if(array[i][j]!=0){
                    arr[index++]=array[i][j];

                }
            }
        }
        System.out.println("以行为主一维数组表示为:");
        System.out.print("[");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println("]");
    }
}

运行结果:

上三角矩阵
7 8 12 21 9 
0 5 14 17 6 
0 0 7 23 24 
0 0 0 32 19 
0 0 0 0 8 
以行为主一维数组表示为:
[7 8 12 21 9 5 14 17 6 7 23 24 32 19 8 ]
下三角矩阵
/*
     * 下三角矩阵:就是一种对角线以上皆为0的n*n矩阵，其中又分为右下三角矩阵和左下三角矩阵。和上三角
     * 矩阵处理方式类似
     * 也可分为“以行为主”和“以列为主”。下面以左下三角矩阵为例：
     * 求A[i][j]在数组中所对应的k值，n*n矩阵。
     * 以行为主：k=i*(i-1)/2+j;
     * 以列为主:k=n*(j-1)+i-j*(j-1)/2;
     * 假如有一个6*6的右上三角矩阵A，以列为主对应到一维数组B，请问a32所对应B(k)的k值多少？
     * k=n*(j-1)+i-j*(j-1)/2=6*(2-1)+3-2*(2-1)/2=8   a23=B(8)
     * 右下三角矩阵:
     * 求A[i][j]在数组中所对应的k值，n*n矩阵。
     * 以行为主：k=i*(i+1)/2+j-n;
     * 以列为主:k=j*(j+1)/2+i-n;
     */
    public static void main(String[] args) {
        int[][] array={{76,0,0,0,0},
                       {54,51,0,0,0},
                       {23,8,26,0,0},
                       {43,35,28,18,0},
                       {12,9,14,35,46}};
        showArray(array);
        result(array);
    }
数组与多项式

多项式是数学中相当重要的表现方式，通常如果用计算机来处理多项式的相关运算，可以将多项式以数组或链表的形式来存储，本节主要讨论多项式以数组结构方式表示相关应用。

package arrays;

public class PolyAdd {
    /*
     * 多项式在数组中的表示方式（n次多项式。例如P(x)=2*x^5+3*x^4+5*x^2+4*x+1为5次多项式。）
     * 1.使用一个n+2长度的一维数组存放，数组的第一个位置存储最大指数n，其他位置按照指数n递减，
     * 一次存储对应关系。
     * A{5,2,3,0,5,4,1}
     * 2.只存储多项式中非零项目，如果有m个非零项，则使用长度为2m+1的数组来存储，数组第一个
     * 元素为非零项的个数
     * A{5,2,5,3,4,5,2,4,1,1,0}
     */
    public static void main(String[] args) {
        int[] PolyA={4,3,7,0,6,2};
        int[] PolyB={4,1,5,2,0,9};
        System.out.print("多项式A=> ");
        printPoly(PolyA);
        System.out.print("多项式B=> ");
        printPoly(PolyB);
        PolySum(PolyA,PolyB);
    }
    private static void PolySum(int[] polyA, int[] polyB) {
        int[] result=new int[polyA[0]+2];
        result[0]=polyA[0];
        for(int i=1;i<result.length;i++){
            result[i]=polyA[i]+polyB[i];
        }
        System.out.print("A加B的和为=>");
        printPoly(result);
    }
    private static void printPoly(int[] poly) {
        int MaxExp;
        MaxExp=poly[0];
        //循环次数
        for(int i=1;i<=poly[0]+1;i++){
            MaxExp--;
            if(poly[i]!=0){//如果该式为零就跳过
                if((MaxExp+1)!=0){
                    System.out.print(poly[i]+"x^"+(MaxExp+1));
                }else{
                    System.out.println(poly[i]);
                }
                if(MaxExp>=0){
                    System.out.print("+");
                }
            }
        }
        System.out.println();
    }
}

运行结果

多项式A=> 3x^4+7x^3+6x^1+2
多项式B=> 1x^4+5x^3+2x^2+9
A加B的和为=>4x^4+12x^3+2x^2+6x^1+11
C丶超少爷
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
右上三角矩阵的压缩（Python实现）
TCatTime的博客
12-07 1868
右上三角矩阵的Python压缩方法解析。
C语言4种二维数组三角题
Yuander的博客
02-18 4229
C语言4种二维数组三角题 此处都以将此三角形的元素乘以n为例 int i,j; for(i=0;i&lt;N;i++) //行编译总是不变 for(j=0;*j&lt;=i*;j++) a[i][j]=a[i][j]*n;![左下三角](https://img-blog.csdnimg.cn/20190218222555883.png) in...
二维数组四个三角形
qq_40667394的博客
02-25 652
左上三角形 int[][] a=new int[4][]; for(int i=0;i<a.length;i++) { a[i]=new int[i+1]; } for(int i=a.length-1;i>=0;i--) { for(int j...
判断上三角矩阵
热门推荐
云杉木屋
12-16 1万+
7-2 判断上三角矩阵（15 分） 上三角矩阵指主对角线以下的元素都为0的矩阵；主对角线为从矩阵的左上角至右下角的连线。本题要求编写程序，判断一个给定的方阵是否上三角矩阵。输入格式：输入第一行给出一个正整数T，为待测矩阵的个数。接下来给出T个矩阵的信息：每个矩阵信息的第一行给出一个不超过10的正整数n。随后n行，每行给出n个整数，其间以空格分隔。输出格式：每个矩阵的判断结果占一行。如果输入的矩阵是
上三角矩阵、矩阵转换、矩阵交换、杨辉三角详解
川子767的博客
12-15 7200
上三角矩阵、矩阵转换、矩阵交换、杨辉三角详解
JAVA数据结构之数组详细教程
01-21
本文整理了java数据结构的数组操作。希望对刚入门数据结构的同志们有帮助。 java数组非常简单。只要有JAVA语言基础就可以看这篇博文。大家不要害怕。。。非常简单。。 整理博客真的很花费时间，如果对大家有帮助，...
数据结构之数组Array实例详解
12-31
数据结构之数组Array实例详解 数组Array 基本操作 Status InitArray(int dimm,...)//若维数dim和随后的各维长度合法，则构造相应的数组A，并返回OK Status DestroyArray() //销毁数组A Status Locate(va_list ap,...
JavaScript数据结构之数组的表示方法示例
10-20
在JavaScript中，数组是一种重要的数据结构，它允许我们存储一组有序的数据。数组的表示方法是基于数据结构理论的线性表概念，线性表是一种基本的一维数据结构，其中元素按照特定顺序排列。在JavaScript中，数组具有...
数据结构之数组翻转的实现方法
01-01
数据结构之数组翻转的实现方法 以下为实现数组翻转的方法： 1.用c语言实现的版本 #include #define M 20 void fun(int *x,int n) { int *i, *j, *p, m=n/2; i = x; j = x+n-1; p = x+m; for( ; i<p; ++i,-...
C语言二维数组下三角、上三角螺旋赋值并打印
m0_56194716的博客
03-19 3465
题目：将一个7*7（只能要求必须行和列相等的矩阵）的二维数组下三角部分以螺旋、依次+1的方式填满并输出（如下图所示） 方法：依旧设置四个变量Left、Right、Up、Down控制循环，不过只有三种模式，故只需要三个for循环（红色线条、蓝色线条、绿色线条）即可解决。 代码如下：（需要注意的已在代码中用注释说明） #include<stdio.h> void Print_Ar(int br[7][7],int n) { for (int i = 0; i < n; i++)
ZZULIOJ 1125: 上三角矩阵的判断
木右加木 就是木木
02-14 956
1125: 上三角矩阵的判断 题目描述 编写程序，输入一个正整数n（1<=n<=10）和n阶方阵a中的元素，如果a是上三角矩阵，输出“YES”，否则，输出“NO”。 上三角矩阵即主对角线以下（不包括主对角线）的元素都为0的矩阵，主对角线为从矩阵的左上角至右下角的连线。 要求定义函数IsUpperTriMatrix()判断矩阵a是否是上三角矩阵，如果是返回1，否则返回0。函数原型如下： ...
编程初学者入门训练-上三角矩阵判定
weixin_48440312的博客
07-02 1519
题目描述 KiKi想知道一个n阶方矩是否为上三角矩阵，请帮他编程判定。上三角矩阵即主对角线以下的元素都为0的矩阵，主对角线为从矩阵的左上角至右下角的连线。 输入描述 第一行包含一个整数n，表示一个方阵包含n行n列，用空格分隔。 (1≤n≤10) 从2到n+1行，每行输入n个整数（范围-231~231-1），用空格分隔，共输入n*n个数。 输出描述 一行，如果输入方阵是上三角矩阵输出"YES"并换行，否则输出"NO"并换行。 示例1 输入 3 1 2 3 0 4 5 0 0 6 输出 YES
变换后矩阵右上三角元素和与左下三角元素和可能的最大差值
夜空中最亮的星
12-24 2802
/*描述 给定一个N行N列的整数矩阵（N 问，调整后的矩阵，右上三角元素和与左下三角元素和可能的最大差值为多少？ 输入格式 第一行为正整数N，此后N行，每行N个整数。 输出格式 任意选定两行进行调换后，可能的最大差值 输入样例 3 1 2 3 4 5 6 7 8 9 输出样例 16 提示 将第1行与第3行交换，8+9+6-4-1-2=16*/ 分析：
34-对称矩阵的压缩存储
网络安全
06-26 1万+
对于矩阵这样由n行n列构成的数据集合，可以通过二维数组来进行存储。 在实际工程中也会用到一些特殊的矩阵， 特殊矩阵可以“压缩”的一种思维来降低空间需求。 （1）对角矩阵 （2）对称矩阵 （3）上三角矩阵／下三角矩阵 1. 对称矩阵的压缩存储 若一个n阶方阵A[n][n]中的元素满足aij=aji（0≤i，j≤n-1），则称其为n阶对称矩阵。 对称矩阵的压缩存储的策略： 存储...
上三角矩阵下三角矩阵
yang6464158的专栏
04-27 1万+
要求给定矩阵，输出其shangsanjiao
【数据结构】堆的实现和堆排序--TOP-K问题
最新发布
2301_78724721的博客
06-21 1040
在头文件中进行堆的定义和接口的声明int size;}HP;//堆的初始化//堆的销毁//堆的插入//堆的删除//取堆顶的数据// 堆的数据个数//堆的判空堆的实现堆是一种特殊的树形数据结构，通常实现为完全二叉树。堆分为最大堆和最小堆，最大堆的父节点值大于或等于其子节点值，而最小堆的父节点值小于或等于其子节点值。堆通常使用数组来实现，通过索引关系模拟树形结构，支持高效的插入、删除和查找最大/最小元素操作。堆排序堆排序是一种基于堆的排序算法。
【数据结构】顺序表
奋斗的小羊的博客
06-18 1913
顺序表超超超详解
数据结构next数组
10-23
Next数组是KMP算法中的一个重要概念，用于快速匹配字符串。它是一个长度与模式串相等的数组，其中每个元素表示在当前位置之前的最长相等前后缀的长度。在匹配过程中，当出现不匹配的情况时，可以利用Next数组中的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值