数据结构之稀疏数组

数据结构之稀疏数组（Sparsearray）

一、使用条件

当一个数组中大部分元素都是0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
eg:记录五指棋的棋盘、发送消息时的大量重复信息

二、处理方法

1）记录数组一共有几行几列，有多少个不同的值；
2）把不同的值得元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

三、图解例子

解析：左边为一个数据比较多的6*7的二维数组，储存的时候会比较多，可以使用稀疏数组储存该二维数组达到提升效率的效果，右图中row代表左图的行，col代表列，val代表值，右图第一行表示左图有6行7列，最多的一个值是0，第二行表示0行3列有一个值是22，0行6列有一个值是15，以此类推完成稀疏数组。

四、原始数组转换为稀疏数组
原始数组初始化，遍历，储存

	var SparseArr [11][11]int
	SparseArr[1][2]=1
	SparseArr[2][3]=2  //初始化数组
    for _,v:=range SparseArr{
		for _,v1:=range v{
			fmt.Printf("%d\t",v1)
		}
		fmt.Println();
	}

输出结果：

转换为稀疏数组

package main
import (
	"fmt"
)
type Sparse struct {
	row int
    col int
	val int
}            //定义稀疏数组的结构
func main(){
	var SparseArr [11][11]int
	var Slice []Sparse
	//标准稀疏数组加上第一行
	Sparse1:=Sparse{
		row:11,
		col:11,
		val:0,
	}
	Slice=append(Slice,Sparse1)
	SparseArr[1][2]=1
	SparseArr[2][3]=2  //初始化数组
    for i,v:=range SparseArr{
		for j,v1:=range v{
			if v1!=0{
				Sparse:=Sparse{
					row:i,
					col:j,
					val:v1,
				}
				Slice=append(Slice,Sparse)
			}
		}
	}
	//构造稀疏数组
   for i,v :=range Slice{
	   fmt.Printf("%d:%d\t%d\t%d\n",i,v.row,v.col,v.val)
   }
   //读取稀疏数组
}

稀疏数组储存结果：

五、稀疏数组转换为原始数组

 //读取稀疏数组
   var SparseArr1[11][11] int
   for i,v:=range Slice{
	   if i!=0{
		   SparseArr1[v.row][v.col]=v.val
	   }
   }
   for _,v:=range SparseArr1{
       for _,v1:=range v{
		   fmt.Printf("%d\t",v1)
	   }
	   fmt.Println()
   }

将稀疏数组保存在文件中，在从文件中读取，即可实现高效率传输。

package main
import (
	"fmt"
	"os"
	"bufio"
	"io"
	"strings"
	"strconv"
)
type Sparse struct {
	row int
    col int
	val int
}            //定义稀疏数组的结构
func main(){
	defer func(){
         err:=recover()
		 if err!=nil{
			 fmt.Println("出现错误")
		 }
	}()
	var SparseArr [11][11]int
	var Slice []Sparse
	//标准稀疏数组加上第一行
	Sparse1:=Sparse{
		row:11,
		col:11,
		val:0,
	}
	Slice=append(Slice,Sparse1)
	SparseArr[1][2]=1
	SparseArr[2][3]=2  //初始化数组
    for i,v:=range SparseArr{
		for j,v1:=range v{
			if v1!=0{
				Sparse:=Sparse{
					row:i,
					col:j,
					val:v1,
				}
				Slice=append(Slice,Sparse)
			}
		}
	}
	//构造稀疏数组
	//文件保存
   var path string ="G:\\Goproject\\goFile.txt"
   file,err:=os.OpenFile(path,os.O_WRONLY|os.O_RDONLY,0666)
   defer file.Close()
   if err!=nil{
	   fmt.Println("出现错误")
   }
   writer:=bufio.NewWriter(file)
   for _,v :=range Slice{
	   str:=fmt.Sprintf("%d\t%d\t%d\n",v.row,v.col,v.val)
	   writer.WriteString(str)
   }
   writer.Flush()
   fmt.Println("储存成功")
   //文件读取
   file1,err:=os.Open(path)
   reader:=bufio.NewReader(file1)
   var i int = 0
   var Slice1 []Sparse
   for{
	str,err:=reader.ReadString('\n')
	if i==0{
		i++
		continue
	}
	if err==io.EOF{
		fmt.Println("读取完毕")
		break
	}
	str=strings.TrimRight(str,"\n")
	arrSplit:=strings.Split(str,"\t")
	row,err:= strconv.Atoi(arrSplit[0])
	col,err:= strconv.Atoi(arrSplit[1])
	val,err:= strconv.Atoi(arrSplit[2]) //string转换为Int
	if err!=nil{
		fmt.Println(err)
	}
	sparse:=Sparse{
         row:row,
		 col:col,
		 val:val,
	}

    Slice1=append(Slice1,sparse)
   }
//    fmt.Println(Slice1)
//    读取稀疏数组
   var SparseArr1[11][11] int
   for _,v:=range Slice1{
		   SparseArr1[v.row][v.col]=v.val
   }
   for _,v:=range SparseArr1{
       for _,v1:=range v{
		   fmt.Printf("%d\t",v1)
	   }
	   fmt.Println()
   }
}

如果这篇文章对大家有帮助，请点赞支持，谢谢