标签：sparseArry JAVA int 冒泡排序 ++ length 数组 nArry
目录二维数组
定义与初始化
二维数组就是在一维数组的基础上，一维数组中的变量不再是普通的变量，而是数组。
二维数组的定义方式如下：
int[][] nArry;
二维数组的初始化方式如下：
方式一、int[][] nArry = new int[][]{{value},{value}...};
方式二、int[][] nArry = new int[size][size];
方式三、int[][] nArry = new int[size][];
获取单个元素
int[][] nArrys = new int[][]{{1, 2}, {3, 4}, {5, 6}};
System.out.println(nArrys[0][0]);
获得每个元素
//获取每个元素
int[][] nArrys = new int[][]{{1, 2}, {3, 4}, {5, 6}};
for (int i = 0; i < nArrys.length; i++) {
for (int j = 0; j < nArrys[i].length; j++) {
System.out.println(nArrys[i][j]);
}
}
获得整行元素
//获取第二行的元素
int[][] nArrys = new int[][]{{1, 2}, {3, 4}, {5, 6}};
for (int i = 0; i < nArrys[1].length; i++) {
System.out.println(nArrys[1][i]);
}
Arrays类
由于数组本身并没有什么方法供我们调用，所以API中提供了一个Arrays类供我们使用。Arrays就是一个数组的工具类，里面包括了很多操作数组的方法java.util.Arrays。
需要注意的时，Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用。
以下展示一些Arrays类中常用的功能：
fill方法给数组赋值
int[] nArry = new int[10];
Arrays.fill(nArry, 9);
for (int i = 0; i < nArry.length; i++) {
System.out.print(nArry[i]+" ");
}
运行结果：
- 通过
sort方法排序
int[] nArry = new int[]{1, 5, 2, 9, 4};
Arrays.sort(nArry);
System.out.println(Arrays.toString(nArry));
运行结果：
可以看出Arrays类是一个很好的操作数组的类，平时在使用过程中有遇到可以查看API帮助文档进行学习。
冒泡排序
原理：比较数组中，两个相邻的元素，如果第一个数字比第二个数字打，我们就交换他的位置：
public static void main(String[] args) {
int[] nArry = new int[]{1, 5, 2, 9, 4};
int nTem = 0;
for (int i = 0; i < nArry.length; i++) {
for (int j = 0; j < nArry.length; j++) {
if (nArry[i] < nArry[j]) {
nTem = nArry[i];
nArry[i] = nArry[j];
nArry[j] = nTem;
}
}
}
System.out.println(Arrays.toString(nArry));
}
稀疏数组
在我们平时的数组使用过程中，有时候会出现一个数组中有大量重复数据的情况，这个时候显然是浪费了很多空间的。
比如以下这个实际情况，一个棋盘中，我们用1表示表示黑棋，用2表示蓝棋，其他地方我们用0表示，这个时候有大量的数字相同的0，此时我们就可以用稀疏数组来代替我们这个复杂的，拥有许多相同数值的数组：
稀疏数组中的第一行代表了原数组有几行几列，并且记录与0不相同的数字的值的个数。
接下来的每一行就代表了与0不相同的数字在原数组中的具体坐标以及值。
接下来我们用代码实现一个稀疏数组：
public class Sparse_Array {
public static void main(String[] args) {
int[][] a = former_Arry();
print_Delimiter();
int[][] b = sparse_Arry(a);
print_Delimiter();
backArry(b);
}
public static int[][] former_Arry() {
//画出原棋盘
int[][] formerarry = new int[11][11];
formerarry[1][2] = 1;
formerarry[2][3] = 2;
for (int i = 0; i < formerarry.length; i++) {
for (int j = 0; j < formerarry[i].length; j++) {
System.out.print(formerarry[i][j] + " ");
}
System.out.println();
}
return formerarry;
}
//稀疏数组
public static int[][] sparse_Arry(int[][] formerArry) {
//判断有几个数字不等于0
int notEqual = 0;
for (int i = 0; i < formerArry.length; i++) {
for (int j = 0; j < formerArry[i].length; j++) {
if (formerArry[i][j] != 0) {
notEqual++;
}
}
}
//创建稀疏数组
int[][] sparseArry = new int[notEqual + 1][3];
sparseArry[0][0] = formerArry.length;
sparseArry[0][1] = formerArry[0].length;
sparseArry[0][2] = notEqual;
int nCount = 1;
for (int i = 0; i < formerArry.length; i++) {
for (int j = 0; j < formerArry[i].length; j++) {
if (formerArry[i][j] != 0) {
sparseArry[nCount][0] = i;
sparseArry[nCount][1] = j;
sparseArry[nCount][2] = formerArry[i][j];
nCount++;
}
}
}
//打印稀疏数组
for (int i = 0; i < sparseArry.length; i++) {
for (int j = 0; j < sparseArry[i].length; j++) {
System.out.print(sparseArry[i][j] + " ");
}
System.out.println();
}
return sparseArry;
}
//从稀疏数组还原原数组
public static int[][] backArry(int[][] sparseArry)
{
int[][] backAryy = new int[sparseArry[0][0]][sparseArry[0][1]];
for (int i = 1; i <= sparseArry[0][2] ; i++) {
backAryy[sparseArry[i][0]][sparseArry[i][1]] = sparseArry[i][2];
}
//打印原数组
for (int i = 0; i < backAryy.length; i++) {
for (int j = 0; j < backAryy[i].length; j++) {
System.out.print(backAryy[i][j]+" ");
}
System.out.println();
}
return backAryy;
}
//打印分隔符
public static void print_Delimiter()
{
System.out.println("===============================");
}
}
运行结果：
标签：sparseArry,JAVA,int,冒泡排序,++,length,数组,nArry 来源： https://www.cnblogs.com/zbcgoal/p/15771480.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。