java 数据结构--------数组、集合和矩阵

今天药忘吃喽~ 2023-10-16 18:41 2阅读 0赞

数组是程序设计最常使用的一种数据结构。高级程序设计语言通常都支持数组功能。集合是某种具有相同数据类型的数据元素全天。矩阵一般采用二维数组存储。数组和矩阵是属于线性结构。

大的矩阵需要的内存单元数量很大，对特殊矩阵和稀疏矩阵可采用一些特殊方法减少内存单元数量，这称为特殊矩阵和稀疏矩阵的压缩存储。

数组

1、数组的定义

数组是n(n>=1)个相同的数据类型的数据元素a1、a2、a3构成的占用一块连续地址的内存单元的有限集合。

数组中任意一个数据元素可以用该元素在数组中的位置来表示，数组元素的位置通常称为数组的下标。Java数组的下标从0开始。

显然，数组符合线性结构的定义。数组和线性表相比，相同之处是它们都是若干个相同的数据类型的数据元素构成的有限序列。不同之处是：数组要求其元素占用一块地址连续的内存单元空间，而线性表无此要求；线性表的元素是逻辑意义上不可再分的元素，而数组中的每个元素还可以是一个数组(二维数组)。数组的操作主要是向某个下标的数组元素中存在的数据和取某个下标的数组元素，这和线性表的插入、删除操作不同。

所有线性结构（包括线性表、堆栈、队列、串、数组和矩阵）的顺序存储结构实际上就是使用数组来存储。可见，数组是其他数据结构实现顺序存储结构的基础，数组这种数据存储结构的软件设计中最基础的数据结构。正因为如此，一般的高级程序设计语言都支持数组功能。

数组的抽象数据类型

1、数据集合

数组的数据集合可以表示为a1、a2、a3,且限定数组元素必须存储在地址连续的内存单元中。

2、操作集合：1、分配内存空间

2、获取数组长度

3、存储数据元素

4、获取数据元素

功能代码：java.util.Vector类

package com.bruteforce;
    
    import java.util.Vector;
    
    public class VectorTest {
    	public static void main(String[] args){
    		//数组向量类---Vector		
    		//初始化长度
    		int length=5;
    		//增量
    		int increase=5;
    		Vector vector=new Vector(length,increase);
    		//数组向量类添加相关数据元素
    		vector.add("c");
    		vector.add("c++");
    		vector.add("c#");
    		vector.add("java");
    		vector.add("php");		
    		
    		int count=vector.capacity();
    		System.out.println("数组向量类当前容量："+count);
    		//指定位置添加数据元素
    		vector.add(5, "ruby");
    		//数组向量类返回指定数据元素
    		String result=(String) vector.elementAt(5);
    		System.out.println("数组向量类返回指定位置数据元素："+result);
    	
    	}
    
    }

结果展示：

![Center][]

集合

集合概念

集合是具有某种相似特性的事物全体。换一种说法，也可以说，集合是某种具有相同数据类型的数据元素全体。

集合的一个重要的特点是其中的数据元素无序且不重复。

集合是一个很大的概念。在这里我们只谈论最基本的几个概念，并在此基础上，讨论集合抽象类抽象数据类型的操作和集合类的设计

集合通常用一对花括号表示。

集合的三种运算：并集、交集和差集。

相关功能代码：参见Java.util.set和java.util.List

矩阵类

1、矩阵类Matrix

矩阵是工程设计中经常使用的数学工具。矩阵的运算主要有矩阵加、矩阵减、矩阵乘、矩阵装置、矩阵求逆。

矩阵用二维数组处理最为方便。大多数的程序也都用二维数组来存储矩阵元素和实现矩阵运算。

相关源代码：

package com.matrix;
    
    import java.util.Random;
    
    public class Matrix {
    	//矩阵元素
    	private int[][] matrix;
      //随机数
    	Random random = new Random();
    
    	// 默认构造方法
    	public Matrix() {
    		matrix = new int[3][3];
    
    	}
        //带参数构造方法（n）
    	public Matrix(int n) {
    		matrix = new int[n][n];
    
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < n; j++) {
    				matrix[i][j] = random.nextInt(100);
    			}
    		}
    	}
            //带参数构造方法（n,m）
    	public Matrix(int n, int m) {
    		matrix = new int[n][m];
    
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < m; j++) {
    				matrix[i][j] = random.nextInt(100);
    			}
    		}
    	}
          //获取矩阵元素方法
    	public int[][] getMatrix() {
    		return matrix;
    	}
    
    	// 输出矩阵中所有元素
    	public void output() {
    		for (int i = 0; i < matrix.length; i++) {
    			for (int j = 0; j < matrix[i].length; j++) {
    				System.out.print(matrix[i][j] + "\t");
    			}
    			System.out.println();
    		}
    	}
    
    	// 求一个矩阵的转置矩阵
    	public Matrix transpose() {
    
    		int n = matrix.length;
    		int m = matrix[0].length;
    
    		Matrix transMatrix = new Matrix(n, m);
    
    		for (int i = 0; i < n; i++) {
    			for (int j = 0; j < m; j++) {
    				transMatrix.getMatrix()[i][j] = matrix[j][i];
    			}
    		}
    
    		return transMatrix;
    	}
    
    	// 判断一个矩阵是否为上三角矩阵
    	public boolean isTriangular() {
    
    		// 用相反的思路进行判断
    		for (int i = 1; i < matrix.length; i++) {
    			for (int j = 0; j < i; j++) {
    				if (matrix[i][j] != 0) {
    					return false;
    				}
    			}
    		}
    
    		return true;
    	}
    
    	// 判断是否为对称矩阵
    	public boolean isSymmetry() {
    
    		for (int i = 1; i < matrix.length; i++) {
    			for (int j = 0; j < matrix[i].length; j++) {
    				if (matrix[i][j] != matrix[j][i]) {
    					return false;
    				}
    			}
    		}
    
    		return true;
    	}
    
    	// 矩阵的相加
    	public void add(Matrix b) {
    
    		int[][] matrixOfB = b.getMatrix();
    
    		int n = matrixOfB.length;
    		int m = matrixOfB[0].length;
    
    		if (n != matrix.length || m != matrix[0].length) {
    			System.out.println("矩阵的长度不一致，不能相加");
    		} else {
    			for (int i = 0; i < n; i++) {
    				for (int j = 0; j < m; j++) {
    					matrix[i][j] += matrixOfB[i][j];
    				}
    			}
    
    		}
    	}
    
    	public static void main(String[] args) {
    
    		// 测试
    		Matrix test1 = new Matrix(4);
    
    		System.out.println("原始矩阵");
    		test1.output();
    
    		Matrix transMatrix = test1.transpose();
    
    		System.out.println("转置矩阵");
    		transMatrix.output();
    
    		System.out.println("是否是上三角矩阵");
    		System.out.println(test1.isTriangular());
    
    		System.out.println("是否是对称矩阵");
    		System.out.println(test1.isSymmetry());
    
    		System.out.println("----------------------");
    
    		Matrix test2 = new Matrix();
    
    		test2.output();
    
    		System.out.println(test2.isTriangular());
    		System.out.println(test2.isSymmetry());
    
    		System.out.println("----------------------");
    
    		Matrix test3 = new Matrix(4);
    		Matrix test4 = new Matrix(4);
    
    		test3.add(test2);
    
    		System.out.println("矩阵1");
    		test3.output();
    		System.out.println("矩阵2");
    		test4.output();
    
    		System.out.println("矩阵相加");
    		test3.add(test4);
    
    		test3.output();
    	}
    
    }

执行结果展示：

![Center 1][]

特殊矩阵

特殊矩阵是指这样一类矩阵，其中许多的值相同的元素或有许多零元素，且值相同的元素或零元素的分布有一定的规律。一般采用二维数组来存储矩阵元素。但是，对于特殊矩阵，可以通过找出矩阵中所有值相同元素的数学映射公式，只存储相同元素的一个副本，从而达到压缩存储数据量的目的。

当矩阵的维数比较大时，矩阵占据的内存单元相对较多，这时，利用特殊矩阵数据元素的分布规律压缩矩阵的存储空间，对许多应用问题来说有重要的意义。

特殊矩阵的压缩存储

特殊矩阵压缩存储方法有两种：只存储相同矩阵元素的一个副本；采用不等长的二维数组。

n阶对称矩阵类源代码：

package com.matrix;
    
    public class SynmeMatrix {
    	//相关属性和构造函数
    	double a[];//矩阵元素
    	int n;//阶数
    	int m;//一维数组个数
    	
    	//相关构造函数
    	public SynmeMatrix(int n){
    		m=n*(n+1)/2;
    		a=new double[m];
    		this.n=n;
    	}
    	//矩阵赋值方法1
    	public void evaluateMatrix(double[][] b){
    		int k=0;
    		int i,j;
    		for(i=0;i<n;i++){
    			for(j=0;j<n;j++){
    				if(i>=j){
    					a[k++]=b[i][j];
    				}
    			}
    		}
    	}
    	//矩阵赋值方法2
    	public void evaluateMatrix(double[] b){
    		for(int k=0;k<m;k++){
    			a[k]=b[k];
    		}
    	}
    	//矩阵相加
    	public SynmeMatrix add(SynmeMatrix myB){
    		SynmeMatrix t=new SynmeMatrix(n);
    		int i,j,k;
    		for(i=1;i<=n;i++){
    			for(j=1;j<=n;j++){
    				if(i>=j){
    					k=i*(i-1)/2+j-1;
    				}else{
    					k=j*(j-2)/2+i-1;
    				}
    				t.a[k]=a[k]+myB.a[k];
    			}
    		}
    		return t;
    	}
    	//矩阵输出
    	public void print(){
    		int i,j,k;
    		for(i=1;i<=n;i++){
    			for(j=1;j<=n;j++){
    				if(i>=j){
    					k=i*(i-1)/2+j-1;
    				}else{
    					k=j*(j-2)/2+i-1;
    				}
    				System.out.println(""+a[k]);
    			}
    			System.out.println();
    		}
    	}
    	public static void main(String[] args){
    		SynmeMatrix matrixA=new SynmeMatrix(3);
    		SynmeMatrix matrixB=new SynmeMatrix(3);
    		
    		SynmeMatrix matrixC;
    		double[][] a={
       {0,0,0},{0,1,0},{0,0,1}};
    		//特殊矩阵赋值
    		matrixA.evaluateMatrix(a);
    		System.out.println("matrixA矩阵为：");
    		matrixA.print();
    		
    		double[] b={1,2,3,4,5,6};
    		//特殊矩阵赋值
    		matrixB.evaluateMatrix(b);
    		System.out.println("matrixB矩阵为：");
    		matrixB.print();
    		
    		//特殊矩阵相加
    		matrixC=matrixA.add(matrixB);
    		System.out.println("特殊矩阵相加结果：");
    		matrixC.print();
    		
    	}
    	
    
    }

稀疏矩阵：待见。

[Center]: https://img-blog.csdn.net/20131105142523328?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhvdXpoaXdlbmdhbmc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 1]: https://img-blog.csdn.net/20131105145438750?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvemhvdXpoaXdlbmdhbmc=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center