稀疏数组学习总结和C++实现代码

1、稀疏数组是什么？

稀疏数组的应用场景是：当普通数组中无效数据量远远大于有效数据量时，可以用稀疏数组对数组进行压缩。
是的，稀疏数组的功能就是进行压缩。节省内存占用，或者节约硬盘占有，网络传输等。

2、实例说明

              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 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 0

其中只有两个数据是有效数据，其它都是初始化的数据值0。所以，只记录这两个值的位置和数值就可以了。

获得稀疏数组形式：

              11 11 2
              1  2  1
              2  3  2

解释：
第0行 总行数，总列数，整个数组有效数据个数。
第1行 第1个有效数据 行号，列号，数据值。
第2行 第2个有效数据 行号，列号，数据值。
…………

3、C++代码实现

稀疏数组基本功能在SparseArray类中。
类代码如下：https://blog.csdn.net/jean7155

//用二维动态数组保存稀疏数组。
//作者：https://blog.csdn.net/jean7155
#ifndef SparseArray_hpp
#define SparseArray_hpp

#include <stdio.h>

class SparseArray
{
public:
    SparseArray();
    ~SparseArray();
    int getValueNum(int* scr,int row,int col);
    
    int createFrom(int* scr,int row,int col);
    void printSparseArray();
    int toArray(int* &des,int &row,int &col);
private:
    void init(int num);
    
    int** mArray;//动态二维数组的指针。
    int mSum;	//有效数据的个数。
};

#endif /* SparseArray_hpp */

//作者：https://blog.csdn.net/jean7155

#include "SparseArray.hpp"
#include <iostream>
SparseArray::SparseArray()
{
    mArray = NULL;
    mSum=0;
}
SparseArray::~SparseArray()
{
    if (mArray!=nullptr) {
        delete mArray;
    }
}
//获得有效数据个数。
int SparseArray::getValueNum(int* scr,int row,int col)
{
    int sum = 0;
    for(int i = 0; i < row; i++) {
        for(int j = 0; j < col; j++) {
            int a = *(scr+i*row+j);
            if(a!=0) {
                sum++;
            }
        }
    }
    return sum;
}
//初始化动态数组。
void SparseArray::init(int num)
{
    mArray = new int*[3];
    for (int i=0; i<num+1; i++) {
        mArray[i] = new int[3]();
    }
}
//将数组转为稀疏数组
int SparseArray::createFrom(int* scr,int row,int col)
{
    int sum = getValueNum(scr, row, col);
    std::cout << "sum = "<<sum <<std::endl;

    //2.创建对应的稀疏数组
    init(sum);
    
    //3.给稀疏数组赋值
    mArray[0][0] = 11;
    mArray[0][1] = 11;
    mArray[0][2] = sum;
    
    //3.遍历二维数组将非零值存放到稀疏数组
    int count = 0;  //  记录是第几个非零数据
    for(int i = 0; i < row; i++) {
        for(int j = 0; j < col; j++) {
            int a = *(scr+i*row+j);
            if(a!=0) {
                count++;
                mArray[count][0] = i;
                mArray[count][1] = j;
                mArray[count][2] = a;
            }
        }
    }
    mSum=count;
    return count;
}
//显示稀疏数组
void SparseArray::printSparseArray()
{
    for(int i = 0; i < mSum+1; i++) {
        std::cout << mArray[i][0] << "\t"<<mArray[i][1]<<"\t"<<mArray[i][2]<<std::endl;
    }
}
int SparseArray::toArray(int* &des,int &row,int &col)
{
    if (des!=nullptr)
        return 0;
    
    //将稀疏数组--->>恢复成原始的二维数组
    //1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
    row = mArray[0][0];
    col = mArray[0][1];
    des = new int[row*col]{};
    
    //2.读取稀疏数组的数据赋给二维数组
    int sum = mArray[0][2];
    for(int i = 1; i <sum+1; i++) {
        int x = mArray[i][0];
        int y = mArray[i][1];
        int value = mArray[i][2];
        des[x*row+y] = value;
    }
    return  sum;
}

测试应用代码：

//作者：https://blog.csdn.net/jean7155

#include <iostream>
#include <vector>
#include "SparseArray.hpp"

void testSparseArray(){
//作者：https://blog.csdn.net/jean7155

    //创建一个二维数组，初始化二维数组。
    int chessArr1[11][11];
    for (int i=0; i<11; i++) {
        for (int j=0; j<11; j++) {
            chessArr1[i][j] = 0;
        }
    }
    chessArr1[1][2]=1;
    chessArr1[2][3]=2;
    
    //输出原始的二维数组
    for (int i=0; i<11; i++) {
        for (int j=0; j<11; j++) {
            std::cout << chessArr1[i][j];
        }
        std::cout << std::endl;
    }

    SparseArray sa;
    int * scr = (int * )chessArr1;
    sa.createFrom(scr, 11, 11);
    //输出稀疏数组的形式
    std::cout<<"得到的稀疏数组为:" << std::endl;
    sa.printSparseArray();
    
    //将稀疏数组--->>恢复成原始的二维数组
    int * des = nullptr;
    int row=0,col=0;
    sa.toArray(des,row,col);
    
    //输出恢复后的二维数组
    std::cout<< "恢复后的原始数组" << std::endl;
    
    for(int i = 0; i < row; i++) {
        for(int j = 0; j < col; j++) {
            std::cout << des[i*row+j] << "\t";
        }
        std::cout << std::endl;
    }
    std::cout<< "稀疏数组实例完成。" << std::endl;
    
    return ;
}

int main(int argc, const char * argv[]) {
    testSparseArray();
}

实现源码放在：
https://github.com/jean7155/Learning-data-structure-and-algorithm

由于我用的是Mac os，所以用的是Xcode的编译环境，工程文件也都是Xcode的。但是我的用的是控制台工程，显示输出用的STL标准库，代码也都是C++标准的。所以直接将文件复制的Windows系统下，问题不大。

我在不断学习各种算法和数据结构，继续添加这个工程的内容。欢迎大家讨论、交流。最好，能发现错误告诉我，那样我就又提高了。

ps：参考文章列表：

稀疏数组
（https://blog.csdn.net/so1125so/article/details/99619761）
通过五子棋的例子讲解的。

https://blog.csdn.net/weixin_41922289/article/details/94555391

数组 - 稀疏数组
（https://blog.csdn.net/weixin_41922289/article/details/94555391）
简单清楚，有图解，有实例。
但是后面的链式存储部分太粗糙了。这个里面涉及的链式存储是关于链表的内容。