经典Java算法题：原数组 与 稀疏数组相互转化

题目：

例如：

稀疏数组的第一行，表示原数组有11行，11列，共有3个有效元素。

稀疏数组的其他行，第一个数字表示有效元素的行号（从0开始），第二个数字表示有效元素的列号（从0开始），第三个数组表示有效元素的值。

实现

package com.briup.day10;

import java.util.ArrayList;

import javax.swing.plaf.basic.BasicInternalFrameTitlePane.IconifyAction;

public class OriAndSpaArr {
	/**
	 * 算法题
	 * 算法题 （选做）
	原数组 此处 稀疏数组 此处 3 行 3 列
	00000000000 2 2 2 总共两行两列 2 个有效数据
	00100000000 1 2 1 第一个有效数据在原数组的位置和值
	.... 横坐标 1， 纵坐标 2 ， 值为 1
	00020000000 2 3 2 第二个有效数据在原数组的位置和值
	00000000000

	思路
	二维数组转稀疏数组
	1.遍历原始的二维数组， 创建有效数据的个数 count
	2.根据 count 就可以创建稀疏数组 sparseArr int[count+1][3]
	3.将二维数组的有效数据存入到稀疏数组
	稀疏数组转原始二维数组
	1.先读取稀疏数组的第一行， 根据第一行的数据， 创建原始的二维数组。
	2.读取稀疏数组后几行的数据， 并赋给原始的二维数组。
	 */
	/**
	 * 单词：
	 * 原始 -- original
	 * 稀疏 -- sparse
	 * @param args
	 */
	//用来打印二维数组
	public static void printArr(int[][] arr) {
		for(int i = 0;i<arr.length;i++) {
			for(int j = 0;j<arr[i].length;j++) {
				System.out.print(arr[i][j]+" ");
			}
			System.out.println();
		}
	}
	//原始数组转稀疏数组
	public static void originalToSparse(int [][] oriArr) {
		System.out.println("原数组：");
		printArr(oriArr);
		ArrayList<Integer> list = new ArrayList<>();
		int row = oriArr.length;
		int column = oriArr[0].length;
		for(int i = 0;i<oriArr.length;i++) {
			for(int j = 0;j<oriArr[i].length;j++) {
				if(oriArr[i][j]!=0) {
					list.add(i);
					list.add(j);
					list.add(oriArr[i][j]);
				}
			}
		}
		int totalNum = list.size()/3;//非0 数字的个数
		int newArr[][] = new int[totalNum+1][3];
		newArr[0][0] = row;
		newArr[0][1] = column;
		newArr[0][2] = totalNum;
		for(int i = 1;i<newArr.length;i++) {
			for(int j = 0;j<newArr[i].length;j++) {
				newArr[i][j] = list.get(j+(i-1)*3);
			}
		}
		System.out.println("原数组转稀疏数组：");
		printArr(newArr);
	}
	//稀疏数组转原始数组
	public static void sparseToOriginal(int [][] sparse) {
		System.out.println("稀疏数组：");
		printArr(sparse);
		int row = sparse[0][0];
		int column = sparse[0][1];
		int[][] original = new int[row][column];
		for(int i = 0;i<original.length;i++) {
			for(int j = 0;j<original[i].length;j++) {
				for(int k = 1;k<sparse.length;k++) {
					if(i == sparse[k][0] && j == sparse[k][1]) {
						original[i][j] = sparse[k][2];
						break;
					}
				}
			}
		}
		System.out.println("稀疏数组转原数组：");
		printArr(original);
	}
}

测试

	public static void main(String[] args) {
		int[][] arr = {
			{0,0,0,0,0,0,0,0},
			{0,0,0,0,1,0,0,0},
			{0,0,2,0,0,0,0,0},
			{0,0,0,3,4,0,0,0}
		};
		OriAndSpaArr.originalToSparse(arr);
	}

	public static void main(String[] args) {
		int[][] sparse = {
				{4 ,8, 4 },
				{1 ,4 ,1 },
				{2, 2 ,2 },
				{3 ,3 ,3 },
				{3, 4 ,4 }
		};
		OriAndSpaArr.sparseToOriginal(sparse);
	}

	public static void main(String[] args) {
		int[][] arr = {
				{0,0,0,0,0,0,0,0,0,0,0},
				{0,0,1,0,0,0,0,0,0,0,0},
				{0,0,0,2,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,2,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0,0,0},
				{0,0,0,0,0,0,0,0,0,0,0},		
		};
		OriAndSpaArr.originalToSparse(arr);
	}

	public static void main(String[] args) {
		int[][] sparse = {
				{11 ,11, 3 },
				{1 ,2 ,1 },
				{2, 3 ,2 },
				{4 ,5 ,2 },
			};
		OriAndSpaArr.sparseToOriginal(sparse);
	}