线性结构，非线性结构，稀疏数组和二维数组的互相转换

主要学习：线性结构和非线性结构，稀疏数组和队列，稀疏数组和二维数组的互相转换

一、线性结构

1.主要特点

（1）元素之间一对一的线性关系，最常用的数据结构

（2）两种存储结构——顺序存储和链式存储，分别对应顺序表和链表

顺序表：存储元素连续

链表：不一定连续，存放数据元素及相邻元素的地址信息

2.常见的线性结构：数组，队列，链表，盏

二、非线性结构

1.常见的：二维数组，多维数组，广义表，树结构，图结构

2.特点：元素之间不是一对一的关系

三、稀疏数组和队列

1.应用场景

2.基本介绍

一个数组中大部分元素为0，或者为同一个值的数组使，使用稀疏数组保存

3.解决方法

（1）记录数组一共有几行几列，有多少个不同的值

（2）把既有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

例子：

 二维数组转换成稀疏数组思路解析：

第一行：记录总共有多少行，多少列，几个有效值

第二行：第一个值—有效数据的行（下标从0开始）；第二个值—有效数据的列；第三个值—有效数据的值

第三行：以第二行类推

package com.atguigu.sparsearray;

public class SparseArrayNew {

	/**普通二维数组转换为稀疏数组的步骤
	 * 1.定义一个二维数组cheerArr【10】【10】
	 * 2.给出在二维数组中有效值的位置
	 * 3.打印看看二维数组是否与预想的相同
	 * 4.遍历二维数组，sum记录不为0 的个数
	 * 5.定义一个稀疏数组sparsearr【sum+1】【3】
	 * 6.给稀疏数组赋值
	 * 6.1第一行特殊：
	 * 第一列：sparsearr【0】【0】=10；
	 * 第二列：sparsearr【0】【1】=10；
	 * 第三列：sparsearr【0】【2】=sum；
	 * 6.2其余行循环赋值，由于列是确定的，为0,1,2；但是行的具体值不确定，需要用count记录，比如第一个有效值在第二行，count=2
	 * 第一列：sparsearr【count】【0】=i；
	 * 第二列：sparsearr【count】【1】=j；
	 * 第三列：sparsearr【count】【2】=cheerArr【i】【j】；
	 * 7.遍历稀疏数组，查看打印的稀疏数组是否正确
	 */
	public static void main(String[] args) {
		//1.定义一个二维数组cheerArr【10】【10】
		int cheerArr[][]=new int [10][10];
		
		//2.给出在二维数组中有效值的位置
		cheerArr[0][1]=1;
		cheerArr[1][2]=3;
		cheerArr[1][8]=10;
		cheerArr[7][7]=4;
		
		//3.打印看看二维数组是否与预想的相同
		for (int i = 0; i < cheerArr.length; i++) {
			for (int j = 0; j < cheerArr.length; j++) {
				System.out.printf("%d",cheerArr[i][j]);
			}
			System.out.println();
		}
		
		//4.遍历二维数组，sum记录不为0 的个数
		int sum=0;
		for (int i = 0; i < cheerArr.length; i++) {
			for (int j = 0; j < cheerArr.length; j++) {
				if(cheerArr[i][j]!=0) {
					sum++;
				}
			}
			
		}
		System.out.println("sum的值为"+sum);
		
		//5.定义一个稀疏数组sparsearr【sum+1】【3】
		int sparseArr[][]=new int[sum+1][3];
		
//		// 6.1第一行特殊：
//		 * 第一列：sparsearr【0】【0】=10；
//		 * 第二列：sparsearr【0】【1】=10；
//		 * 第三列：sparsearr【0】【2】=sum；
		sparseArr[0][0]=10;
		sparseArr[0][1]=10;
		sparseArr[0][2]=sum;
		
//		6.2其余行循环赋值，由于列是确定的，为0,1,2；但是行的具体值不确定，需要用count记录，比如 
           第一个有效值在第二行，count=2
//				 * 第一列：sparsearr【count】【0】=i；
//				 * 第二列：sparsearr【count】【1】=j；
//				 * 第三列：sparsearr【count】【2】=cheerArr【i】【j】；
		int count=0;
		for (int i = 0; i < cheerArr.length; i++) {
			for (int j = 0; j < cheerArr.length; j++) {
				if(cheerArr[i][j]!=0) {
					count++;
					sparseArr[count][0]=i;
					sparseArr[count][1]=j;
					sparseArr[count][2]=cheerArr[i][j];
				}
				
			}
		}
		
		//7.遍历稀疏数组，查看打印的稀疏数组是否正确
		for (int i = 0; i < sparseArr.length; i++) {
				System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
			}
		
		
		/**稀疏数组转化成二维数组的步骤：
		 * 1.建立一个二维数组
		 * 2.给二维数组赋值
		 * 2.1由稀疏数组的第一行可知，第一行的第一列数据可以直接得到sparseArr【0】【0】=二维数组的第一个值，
		 * 第一行的第二列数据可以直接得到sparseArr【0】【1】=二维数组的第二个值
		 * 2.2循环遍历稀疏数组，但要从第二行开始，cheerArr2【sparseArr【i】【0】】【sparseArr【i】【1】】=sparsArr【i】【j】
		 * 3.遍历二维数组查看结果是否正确
		 */
		//1.建立一个二维数组
//		// * 2.给二维数组赋值
//		 * 2.1由稀疏数组的第一行可知，第一行的第一列数据可以直接得到sparseArr【0】【0】=二维数组的第一个值，
//		 * 第一行的第二列数据可以直接得到sparseArr【0】【1】=二维数组的第二个值
		System.out.println();
		int cheerArr2[][]=new int [sparseArr[0][0]][sparseArr[0][1]];
		
//* 2.2循环遍历稀疏数组，但要从第二行开始，cheerArr2【sparseArr【i】【0】】【sparseArr【i】【1】】=sparsArr【i】【j】
		for (int i = 1; i < sparseArr.length; i++) {
			cheerArr2[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
}
		
		//		 * 3.遍历二维数组查看结果是否正确

		for (int i = 0; i < cheerArr2.length; i++) {
			for (int j = 0; j < cheerArr2.length; j++) {
				System.out.printf("%d",cheerArr2[i][j]);
			}
			System.out.println();
		}
		
		
			
	}
	
}