用Java实现矩阵的相加、相乘、转置和稀疏矩阵的操作

电玩女神 2022-11-16 15:14 128阅读 0赞

——————————————————————————————————————————————————

## 1、矩阵的相加 ##

矩阵的相加运算比较简单，前提是相加的两个矩阵行数与列数必须相等。代码如下：

import java.io.*;
    
    public class CH02_02 { 
    
        public static void MatriAdd(int arrA[][], int arrB[][], int arrC[][], int dimX, int dimY)
        { 
                int row, col;
                if(dimX <= 0 || dimY <= 0)
                { 
                    System.out.println("矩阵维数必须大于0");
                    return;
                 }
                for(row = 1; row <= dimX; row++)
                { 
                    for(col = 1; col <= dimY; col++)
                    { 
                        arrC[(row-1)][(col-1)] = arrA[(row-1)][(col-1)] + arrB[(row-1)][(col-1)];
                    }
                }
        }
        
        public static void main(String[] args) throws IOException{ 
            int i, 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的各个元素]");
            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的各个元素]");
             for(i = 0; i < 3; i++)
            { 
                for(j = 0; j < 3; j++)
                    System.out.print(B[i][j] + " \t");
                System.out.println();
            }
             
             MatriAdd(A, B, C, 3, 3);
             
             
             System.out.println("[显示矩阵A和矩阵B相加的结果]");
             
             for(i = 0; i < 3; i++)
             { 
                 for(j = 0; j < 3; j++)
                     System.out.print(C[i][j] + " \t");
                 System.out.println();
             }
         
        }
    
    }

## 2、矩阵相乘 ##

例如：两个矩阵A与B的相乘，是有某些限制条件的。首先必须符合A为一个m*n的矩阵，B为一个n*p的矩阵，对A*B之后的结果为一个m*p的矩阵C。代码如下：

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */
    package ch02_03;
    import java.io.*;
    /** * * @author 604 */
    public class CH02_03 { 
    
        public static void main(String[] args) throws IOException{ 
            // TODO code application logic here
            int M, N, P;
            int i, j;
           
            String strM, strN, strP, tempstr;
            BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入矩阵A的维数（M,N): ");
            System.out.println("请先输入矩阵A的M值");
            strM = keyin.readLine();
            M = Integer.parseInt(strM);
            System.out.println("请输入矩阵A的N值");
            strN = keyin.readLine();
            N = Integer.parseInt(strN);
            int A[][] = new int [M][N];
            System.out.println("[请输入矩阵A的各个元素]");
            System.out.println("注意！ 每输入一个值按下Enter键确认输入");
            for(i = 0; i < M; i++)
            { 
                for(j = 0; j < N; j++)
                { 
                    System.out.println("a"+i+j+"=");
                    tempstr = keyin.readLine();
                    A[i][j] = Integer.parseInt(tempstr);
                }
            }
            
            System.out.println("请输入矩阵B的维数（N,P): ");
            System.out.println("请先输入矩阵B的N值");
            strN = keyin.readLine();
            N = Integer.parseInt(strN);
            System.out.println("请输入矩阵B的P值");
            strP = keyin.readLine();
            P = Integer.parseInt(strP);
            int B[][] = new int [N][P];
            System.out.println("[请输入矩阵B的各个元素]");
            System.out.println("注意！ 每输入一个值按下Enter键确认输入");
            for(i = 0; i < N; i++)
            { 
                for(j = 0; j < P; j++)
                { 
                    System.out.println("B"+i+j+"=");
                    tempstr = keyin.readLine();
                    B[i][j] = Integer.parseInt(tempstr);
                }
            }
            
            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]);
                    System.out.print('\t');
                }
                System.out.println();
            }
            
        }
        
        public static void MatrixMultiply(int arrA[][], int arrB[][], int arrC[][], int M, int N, int P)
        { 
            int i, j, k, Temp;
            if(M <= 0 || N <= 0 || P <= 0)
            { 
                System.out.println("[错误：维数M，N，P必须大于0]");
                return;
            }
            for(i = 0; i < M; i++)
            { 
                for(j = 0; j < P; j++)
                { 
                    Temp = 0;
                    for(k = 0; k < N; k++)
                        Temp = Temp + arrA[i][k] * arrB[k][j];
                    arrC[i][j] = Temp;
                }
            }
        }
        
    }

## 3、转置矩阵 ##

假设A为m*n矩阵，则A的转置矩阵为n*m。代码如下：

import java.io.*;
    
    public class CH02_04 { 
    
        public static void main(String[] args) throws IOException{ 
            // TODO code application logic here
            int M, N, row, col;
            String strM;
            String strN;
            String tempstr;
           BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
            
            System.out.println("[输入M*N矩阵的维度]");
            System.out.println("请输入维度M:");
            strM = keyin.readLine();
            M = Integer.parseInt(strM);
            System.out.println("请输入维度N: ");
            strN = keyin.readLine();
            N = Integer.parseInt(strN);
            
            int arrA[][] = new int [M][N];
            int arrB[][] = 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 + "=");
                    tempstr = keyin.readLine();
                    arrA[row-1][col-1] = Integer.parseInt(tempstr);
                }
                
            }
            
            System.out.println("[输入矩阵内容为]\n");
            for(row = 1; row <= M; row++)
            { 
                for(col = 1; col <= N; col++)
                { 
                    System.out.print(arrA[(row-1)][(col-1)]);
                    System.out.print('\t');
                }
                System.out.println();
            }
            
            for(row = 1; row <= N; row++)
            { 
                for(col = 1; col <= M; col++)
                { 
                    arrB[(row-1)][col-1] = arrA[(col-1)][(row-1)];
                }
               
            }
             System.out.println("[转置矩阵的内容为]");
            for(row = 1; row <= N; row++)
            { 
                for(col = 1; col <= M; col++)
                { 
                    System.out.print(arrB[(row-1)][col-1]);
                    System.out.print('\t');
                }
                System.out.println();
            }     
        }
        
    }

## 4、稀疏矩阵 ##

对于稀疏矩阵，如果直接用传统的二维数组来存储也可以，但事实上有许多元素都是0。这样的做法对于矩阵很大的稀疏矩阵，就会浪费内存空间。而改进空间浪费的方法就是利用**三项式的数据结构**，代码如下：

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */
    package ch02_05;
    
    import java.io.*;
    
    public class CH02_05 { 
    
        public static void main(String[] args) throws IOException{ 
            // TODO code application logic here
            final int _ROWS = 8;//定义行数
            final int _COLS = 9;//定义列数
            final int _NOTZERO = 8;//定义稀疏矩阵中不为0的个数
            int i, j, tmpRW, tmpCL, tmpNZ;
            int temp = 1;
            int Sparse[][] = new int [_ROWS][_COLS];//声明稀疏矩阵
            int Compress[][] = new int [_NOTZERO+1][3];//声明压缩矩阵
            for(i = 0; i < _ROWS; i++)
            { 
                for(j = 0; j < _COLS; j++)
                { 
                    Sparse[i][j] = 0;
                }
            }
            tmpNZ = _NOTZERO;
            for(i = 1; i < tmpNZ+1; i++)
            { 
                tmpRW = (int)(Math.random()*100);
                tmpRW = (tmpRW % _ROWS);
                tmpCL = (int)(Math.random()*100);
                tmpCL = (tmpCL % _COLS);
                if(Sparse[tmpRW][tmpCL] != 0)
                { 
                    //避免同一个元素设定两次数值而造成压缩矩阵中有0
                    tmpNZ++;
                }
                Sparse[tmpRW][tmpCL] = 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();
            }
        }
        
    }