稀疏数组+动态内存分配生成二维数组

当一个数组中大部分元素为0，或者同一个数时。可以使用稀疏数组来保存。

稀疏数组的处理方式:
1.记录数组一共有几行几列，有多少个不同的值。
2.把不同值得元素记录在同一个数组中。

使用方法

1. 二维数组转稀疏数组:
   1. 遍历原始二维数组，得带有效数据的个数
   2. 根据sum 确定 创建 稀疏数组 sparseArr int[sum+1][3]
   3. 将有效数据存入到稀疏数组
2. 稀疏数组–>二维数组：
   1. 先读取稀疏数组第一行，创建原始的二维数组
   2. 读取后几行数据，并赋给原始二维数组

// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
using namespace std;

int main()
{
	//int chess[2][2] = {0};
	//chess[1][2] = 1;
	//chess[1][2] = 2;
	//cout << "原始棋盘" << endl;
	int a[10][10] = { 0 };
	a[1][1] = 1;
	a[2][2] = 2;

	// 用index实现遍历
	for (size_t i = 0; i < sizeof(a)/sizeof(a[0]); i++)
	{
		for (size_t j = 0; j < sizeof(a[0])/sizeof(int); j++)
		{
			cout << a[i][j] << " ";
		}
		cout << " " << endl;
	}

	cout << "------------------------------" << endl;

	// 将其变成稀疏矩阵
	int sum = 0;
	for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		for (size_t j = 0; j < sizeof(a[0]) / sizeof(int); j++)
		{
			if (a[i][j] != 0)
			{
				sum++;
			}
		}
	}

	// 由于数组长度是变量，该处使用了动态内存分配
	int (*sparseArray)[3];
	sparseArray = new int[sum + 1][3];
	sparseArray[0][0] = 10;
	sparseArray[0][1] = 10;
	sparseArray[0][2] = sum;

	int num = 0;

	for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		for (size_t j = 0; j < sizeof(a[0]) / sizeof(int); j++)
		{
			if (a[i][j] != 0)
			{
				num++;
				sparseArray[num][0] = i;
				sparseArray[num][1] = j;
				sparseArray[num][2] = a[i][j];
			}
		}
	}

	for (size_t i = 0; i < sum+1; i++)
	{
		for (size_t j = 0; j < 3; j++) 
		{
			cout << sparseArray[i][j] << " ";
		}
		cout << " " << endl;
	}

	
	// 动态内存分配方法二

	cout << "------------------------------" << endl;
	int u = 10;
	int** test = new int*[u];
	for (size_t i = 0; i < u; i++)
	{
		test[i] = new int [u];
	}
	test[0][0] = 10;
	test[0][1] = 10;
	test[0][2] = sum;
	int v = 0;

	for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		for (size_t j = 0; j < sizeof(a[0]) / sizeof(int); j++)
		{
			if (a[i][j] != 0)
			{
				v++;
				test[v][0] = i;
				test[v][1] = j;
				test[v][2] = a[i][j];
			}
		}
	}

	for (size_t i = 0; i < sum + 1; i++)
	{
		for (size_t j = 0; j < 3; j++)
		{
			cout << test[i][j] << " ";
		}
		cout << " " << endl;
	}

	delete[] test;


	// 使用稀疏矩阵时，需要将其转换为常规数组
	cout << "-----------------稀疏矩阵->原始矩阵---------------" << endl;
	int** origin = new int*[sparseArray[0][0]];                  // 确定行数
	for (size_t i = 0; i < sparseArray[0][0]; i++)
	{
		origin[i] = new int[sparseArray[0][1]]();                // 确定列数，并初始化为0
	}



	for (size_t i = 1; i < sum+1; i++)
	{
		origin[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];  
	}

	for (size_t i = 0; i < sparseArray[0][0]; i++)
	{
		for (size_t j = 0; j < sparseArray[0][1]; j++)
		{
			cout << origin[i][j] << " ";
		}
		cout << " " << endl;
	}


	delete[] sparseArray;
	delete[] origin;


	cout << sizeof(a)/sizeof(int) << endl;
	system("pause");
	return 0;

}

C++中int *p[4]和 int (*q)[4]的区别： https://blog.csdn.net/ajioy/article/details/6951643

动态内存分配生成二维数组

想在数组长度使用变量，需要使用了动态内存分配

使用二级指针生成二维数组

	// 方法1
	int (*sparseArray)[col];
	sparseArray = new int[row][col];
	// 方法2
	int** test = new int*[row];
	for (size_t i = 0; i < row; i++)
	{
		test[i] = new int [col];
		// test[i] = new int [col]();初始化为0；
	}
	
	for (int i = 0; i < row; i ++)
	{
     delete[] test[i];
	}
	delete [] test ；

上述方法中

test[i]相当于每行的地址；
test[i][j]相当于第i行第j个数的值；

再举个例子

int** migong::creator(int row, int col) {
	int** array = new int*[row];
	for (size_t i = 0; i < row; i++)
	{
		array[i] = new int[col]();
	}
	return array;
}

int row = 4;
	int col = 3;
	auto p = map->creator(row, row);
	for (size_t i = 0; i < row; i++)
	{
		for (size_t j = 0; j < 3; j++)
		{
			p[i][j] = (i+1) * (1+j);
			cout << p[i][j] << " ";
		}
		cout << " " << endl;
	}

	cout << "-------------" << endl;
	cout <<"p[0][0] = "<< *p[0] << endl;
	cout << "p[0][1] = " << *(p[0]+1) << endl;
	cout << "p[1][0] = " << *p[1] << endl;
	cout << "p[1][1] = " << *(p[1] + 1) << endl;

	for (size_t i = 0; i < row; i++)
	{
		delete p[i];
	}
	delete[] p;

结果如图

使用vector创建二维数组

//第一种方法
	int m = 4;  // row
	int n = 3;  // column
	vector<vector<int> > array(m); //这个m一定不能少//vector<int> array[m];
	//初始化一个m*n的二维数组
	for (int i = 0; i < m; i++)
	{
		array[i].resize(n);
	}
	//遍历赋值
	for (auto i = 0; i < array.size(); i++)
	{
		for (auto j = 0; j < array[0].size(); j++)
		{
			array[i][j] = (i + 1)*(j + 1);
			cout << array[i][j] << " ";
		}
		cout << " " << endl;
	}

	cout << "-------------" << endl;

	// 第二种方法
	vector<vector<int>> matrix(m, vector<int>(n));
	for (auto i = 0; i < matrix.size(); i++)
	{
		for (auto j = 0; j < matrix[0].size(); j++)
		{
			matrix[i][j] = (i + 1)*(j + 1);
			cout << matrix[i][j] << " ";
		}
		cout << " " << endl;
	}

第二种方法比较简单