将对称矩阵压缩存储，实现矩阵相乘，输出相乘后结果（用二维数组）

    数组地址的传送是我很容易弄错的地方，很惭愧没有学好c和c++知识，

   之前是用基本的二维数组弄得，没有用到数据结构里的数组，现将改进后的代码粘在上面，便于以后的对比复习和再学习。

  两者的算法是一样，所以说算法很重要！

一、没有数据结构里的数组做的

#include "stdafx.h"
#include<iostream>
#include<stdio.h>
#include<math.h>
#define N 2
using namespace std;
//函数声明部分
void Error(char *s);                         //错误处理函数
void Creat_Matrix(int sk[]);                  //创建一个对称矩阵函数
void Muli_Matrix(int sk1[], int sk2[],int sk3[][N]);//两个对称矩阵相称，并将结果保存在sk中
void Print_sk(int sk[]);                     //输出压缩后的函数
void Print_Matrix(int sk[][N]);              //输出对称矩阵函数
int MAX(int a, int b);                       //取a、b中的最大值
int MIN(int a, int b);                       //取a、b中的最小值
//函数定义部分
void Error(char *s)
{
	std::cout << s << endl;
	exit(1);
}
int MAX(int a, int b)  
{
	if (a >= b)
		return a;
	else
		return b;
}
int MIN(int a, int b)
{
	if (a <= b)
		return a;
	else
		return b;
}
void Creat_Matrix(int sk[N*(N + 1) / 2])
{
	int data = 0;
	int i = 0;
	int j = 0;
	for (int a = 0; a <(N*(N + 1) / 2); a++)
	{
		cout << "请输入行标和列标：";
		cin >> i >> j;
		cout << "请输入该行标和列标对应的数据：";
		cin >> data;
		int m = MAX(i, j);
		int n = MIN(i, j);
		sk[m*(m + 1) / 2 + n] = data;
	}
}
void Print_sk(int sk[])
{
	cout << "压缩后的一维数组元素是：";
	for (int i = 0; i < (N*(N + 1) / 2); i++)
	{
		cout << sk[i] << " ";
	}
	cout << endl;
}
void Print_Matrix(int sk[][N])   //输出函数
{  
	//将一维数组元素还原到二维数组并输出
	for (int row = 0; row <N; row++)
	{
		for (int col = 0; col <N; col++)
		{
			cout << sk[row][col]<<"  ";
		}
		cout << endl;
	}
}
void  Muli_Matrix(int sk1[N],int sk2[N],int sk3[][N]) //两个对称矩阵相称，并将结果保存在m中
{
	int i, j;
	for (i= 0; i < N; i++)
	{
		for (j = 0; j < N; j++)
		{
	        sk3[i][j] = 0;
			for (int k = 0; k < N; k++)
			{
				int a = MAX(i, k);
				int b = MIN(i, k);
				int c = MAX(k, j);
				int d = MIN(k, j);
				sk3[i][j] += sk1[a*(a + 1) / 2 + b] * sk2[c*(c + 1) / 2 + d];
			}
		}
	}	
}

int _tmain(int argc, _TCHAR* argv[])
{   int n=0;
    int sk1[N*(N + 1) / 2];
	Creat_Matrix(sk1);
	Print_sk(sk1);
	int sk2[N*(N + 1) / 2];
	Creat_Matrix(sk2);
	Print_sk(sk2);
	int sk3[N][N] = { 0 };
	Muli_Matrix(sk1, sk2, sk3);
	Print_Matrix(sk3);
	return 0;
}

二、用数据结构里的数组做的

// 对称矩阵相乘实现.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include<iostream>
#include<stdio.h>
#include<math.h>
#include<iomanip>
using namespace std;
typedef struct
{
	int *base;
	int b1, b2;
}Array;
//函数声明部分
void Error(char *s);                                 //错误处理函数
void Creat_Matrix(int sk[], int M);                  //创建一个对称矩阵函数
void Muli_Matrix(int sk1[], int sk2[], Array &a, int m, int n);//两个对称矩阵相称，并将结果保存在a中
void Print_sk(int sk[], int M);                       //输出压缩后的一维数组函数函数
void Print_Matrix(Array &a, int m, int n);            //输出对称矩阵解压后的函数
int MAX(int a, int b);                                //取a、b中的最大值
int MIN(int a, int b);                                //取a、b中的最小值
void Init_Array(Array &a, int m, int n);          //初始化一个m行n列的数组
void Destroy_Array(Array &a);                     //销毁一个数组
int  Value_Array(Array &a, int &e, int m, int n); //取值操作实现
void Assig_Array(Array &a, int &e, int m, int n); //数组赋值实现
//函数定义部分
void Error(char *s)
{
	std::cout << s << endl;
	exit(1);
}
int MAX(int a, int b)
{
	if (a >= b)
		return a;
	else
		return b;
}
int MIN(int a, int b)
{
	if (a <= b)
		return a;
	else
		return b;
}
void Creat_Matrix(int sk[], int M)
{
	int data = 0;
	int i = 0;
	int j = 0;
	for (int a = 0; a <M; a++)
	{
		cout << "请输入行标和列标：";
		cin >> i >> j;
		cout << "请输入该行标和列标对应的数据：";
		cin >> data;
		int m = MAX(i, j);
		int n = MIN(i, j);
		sk[m*(m + 1) / 2 + n] = data;
	}
}
void Print_sk(int sk[], int M)
{
	cout << "压缩后的一维数组元素是：";
	for (int i = 0; i < M; i++)
	{
		cout << sk[i] << " ";
	}
	cout << endl;
}
void Init_Array(Array &a, int m, int n)        //初始化一个m行n列的数组
{
	a.base = new int[m*n];
	if (!a.base)
		Error("内存申请失败！");
	a.b1 = m;
	a.b2 = n;
	int b = 0;
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			Assig_Array(a, b, i, j);
		}
	}
}
void Destroy_Array(Array &a)                   //销毁一个数组
{
	delete[] a.base;
	a.b1 = 0;
	a.b2 = 0;
}

int Value_Array(Array &a, int &e, int i, int j) //取值操作实现
{
	if ((0 <= i) && (i < a.b1) && (0 <= j) && (j < a.b2))
	{
		int off = a.b2*i + j;
		e = a.base[off];
	}
	else
		Error("输入参数错误！");
	return e;
}
void Assig_Array(Array &a, int &e, int i, int j) //数组赋值实现
{
	if ((0 <= i) && (i < a.b1) && (0 <= j) && (j < a.b2))
	{
		int off = a.b2*i + j;
		a.base[off] = e;
	}
	else
		Error("输入参数错误！");
}
void Print_Matrix(Array &a, int m, int n)   //输出函数
{
	//将一维数组元素还原到二维数组并输出
	int e = 0;
	for (int row = 0; row <m; row++)
	{
		for (int col = 0; col <n; col++)
		{
			cout << setiosflags(ios_base::left) << setw(6) << Value_Array(a, e, row, col);
		}
		cout << endl;
	}
}
void  Muli_Matrix(int sk1[], int sk2[], Array &t, int m, int n) //两个对称矩阵相称，并将结果保存在t中
{
	int i, j;
	for (i = 0; i < m; i++)
	{
		for (j = 0; j < n; j++)
		{
			int e = 0;
			for (int k = 0; k < n; k++)
			{
				int a = MAX(i, k);
				int b = MIN(i, k);
				int c = MAX(k, j);
				int d = MIN(k, j);
				e += sk1[a*(a + 1) / 2 + b] * sk2[c*(c + 1) / 2 + d];
			}
			Assig_Array(t, e, i, j);
		}
	}
}
int _tmain(int argc, _TCHAR* argv[])
{
	int N = 0;
	cout << "请输入阶数：";
	cin >> N;
	int m = N*(N + 1) / 2;
	int *array1 = new int[m];
	Creat_Matrix(array1, m);
	Print_sk(array1, m);
	int *array2 = new int[m];
	Creat_Matrix(array2, m);
	Print_sk(array2, m);
	Array array3;
	Init_Array(array3, m, m);
	Muli_Matrix(array1, array2, array3, N, N);
	Print_Matrix(array3, N, N);
	delete[] array1;
	delete[] array2;
	return 0;
}