go稀疏数组

1.从原始数组到稀疏数组

1.1遍历原始数组,得到有效数据的个数sum;
1.2根据有效数据个数sum,创建稀疏数组sparseArr[sum+1][3];
1.3遍历原始数组bootData,把有效数据存入稀疏数组sparseArr中,其中第一行存入原始数组的行数,列数,以及有多少有效数据sum;以后每一行存入有数据数据的行号,列号,以及值;

2.从稀疏数据还原为原始数组

2.1回显原始数组bootData;
2.2取稀疏数组sparseArr第一行sparseArr[0],初始化原始数组,其中sparseArr[0][0]为原始数组的行数,sparseArr[0][1]为原始数组的列数,sparseArr[0][2]为有效数据个数;
2.3从第2行开始遍历稀疏数组,为原始数组填充值;

代码实现

package main

import (
	"fmt"
)

type data [11][11]int

const (
	// 行
	h = 11
	// 列
	l = 11
)

// 1.1遍历原始数组,得到有效数据的个数sum;
// 1.2根据有效数据个数sum,创建稀疏数组sparseArr[sum+1][3];
// 1.3遍历原始数组bootData,把有效数据存入稀疏数组sparseArr中,其中第一行存入原始数组的行数,列数,以及有多少有效数据sum;以后每一行存入有数据数据的行号,列号,以及值;
//
// 2.1回显原始数组bootData;
// 2.2取稀疏数组sparseArr第一行sparseArr[0],初始化原始数组,其中sparseArr[0][0]为原始数组的行数,sparseArr[0][1]为原始数组的列数,sparseArr[0][2]为有效数据个数;
// 2.3从第2行开始遍历稀疏数组,为原始数组填充值;
func main() {
	fmt.Printf("start 稀疏数组: %s\n", "start")
	// 创建原始的数组
	bootData := initBootArr()
	sum := getItemCounts(bootData)
	fmt.Printf("有效元素个数:%v\n", sum)
	// 把原始数组转为稀疏数组
	sparseArr := handleSparseArr(bootData, sum)
	fmt.Printf("压缩后的数组:\n")
	for i := 0; i < len(sparseArr); i++ {
		for j := 0; j < 3; j++ {
			fmt.Printf("%v\t", sparseArr[i][j])
		}
		println()
	}
	// 把稀疏数组转为原始数组
	bootArr := handleSparseArrToBootArr(sparseArr)
	fmt.Printf("还原后的数组:\n")
	for i := 0; i < len(bootArr); i++ {
		for j := 0; j < len(bootArr[i]); j++ {
			fmt.Printf("%v\t", bootArr[i][j])
		}
		println()
	}

}

// 初始化根数组
func initBootArr() data {
	var bootArr [h][l]int
	bootArr[1][2] = 1
	bootArr[2][3] = 2
	bootArr[10][9] = 1
	return bootArr
}

// 获取有效元素个数
func getItemCounts(d data) int {
	var sum int
	for i := 0; i < len(d); i++ {
		for j := 0; j < len(d[i]); j++ {
			fmt.Printf("%v\t", d[i][j])
			if d[i][j] > 0 {
				sum++
			}
		}
		println()
	}
	return sum
}

// 压缩数组为稀疏数组
func handleSparseArr(d data, sum int) [][3]int {
	sparseArr := make([][3]int, 0)
	first := [3]int{h, l, sum}
	sparseArr = append(sparseArr, first)

	for i := 0; i < len(d); i++ {
		for j := 0; j < len(d[i]); j++ {
			if d[i][j] > 0 {
				item := [3]int{i, j, d[i][j]}
				sparseArr = append(sparseArr, item)
			}
		}
	}

	return sparseArr
}

// 稀疏数组还原为原始数组
func handleSparseArrToBootArr(d [][3]int) [][]int {
	if len(d) == 0 {
		fmt.Printf("稀疏数组不存在\n")
	}
	// 获取原始数组有多少行,有多少列
	x := d[0][0]
	y := d[0][1]
	sum := d[0][2]
	fmt.Printf("原数据行:%v, 列:%v\n", x, y)

	bootArr := make([][]int, 0)
	for i := 0; i < x; i++ {
		itemData := make([]int, y)
		bootArr = append(bootArr, itemData)
	}

	for j := 1; j <= sum; j++ {
		bootArr[d[j][0]][d[j][1]] = d[j][2]
	}

	return bootArr

}