最佳答案

这个问题还是比较容易实现的。我设计的程序实现了类似于下面的功能：

<1> 矩阵用一维数组表示；

<2> 矩阵1 = {1, 2, 3}，矩阵2 = {4, 5, 6, 7}，矩阵3 = {8, 9}；

<3> 依次将矩阵1、矩阵2、矩阵3加入矩阵列表之中；

<4> 打印矩阵列表结果如下图所示：

其中的数字0是在宏定义（后面代码中会有说明，名称为DEFAULT_NUM）中默认的替换数字，假如矩阵之间长度不一致，短的矩阵缺失的位置就用这个宏定义数字来代替。下面是程序代码：

-----------------------------------------------------------------------

/**

Filename: Matrix.c

Author : grass_rt

*/

#include <stdio.h> // 打印信息

#include <stdlib.h> // 动态分配内存

#define SUCCEED (1) // 成功标识

#define FAILED (0) // 失败标识

// 打印时，如果矩阵长度不一致。

// 对于长度不足的矩阵，为了填补不足而默认打印的数字。

#define DEFAULT_NUM (0)

// 定义矩阵节点

typedef struct matrix {

int* data; // 指向矩阵的信息

int len; // 矩阵中的元素个数

struct matrix* next; // 指向下一个矩阵节点

} m_node;

m_node* m_list = NULL; // 定义最终的矩阵节点列表

m_node* last = NULL; // 指向矩阵列表中的最后一个节点的指针

int max_len = 0; // 矩阵节点的最大长度

int num = 0; // 矩阵列表中的矩阵节点格式

/**

m_node* create_node(int array[], int len);

作用:

将数组转换为一个矩阵节点。

参数列表:

1. int array[]: 数值数组。

2. int len : 数组长度。

返回值：

新生成的矩阵节点指针。

如果int len等于0或array指向NULL，则返回NULL。

*/

m_node* create_node(int array[], int len);

/**

int enqueue(m_node* node);

作用：

将矩阵节点加入矩阵节点列表。

参数列表：

1. m_node* node: 要加入列表的节点。

返回值：

如果m_node* node指向NULL，则返回宏定义FAILED。

否则，返回SUCCEED。

*/

int enqueue(m_node* node);

/**

void print_list(m_node* list);

作用：

打印矩阵节点列表。

参数列表：

1. m_node* list: 要打印的矩阵列表

返回值：

无

*/

void print_list(m_node* list);

int main(void) {

int m1[] = {1, 2, 3}; // 矩阵1

int m2[] = {4, 5, 6, 7}; // 矩阵2

int m3[] = {8, 9}; // 矩阵3

m_node* m_ptr; // 临时矩阵节点指针

// 将数组1转换为矩阵节点

m_ptr = create_node(m1, 3);

// 将矩阵节点1加入矩阵列表

enqueue(m_ptr);

// 将数组2转换为矩阵节点

m_ptr = create_node(m2, 4);

// 将矩阵节点2加入矩阵列表

enqueue(m_ptr);

// 将数组3转换为矩阵节点

m_ptr = create_node(m3, 2);

// 将矩阵节点3加入矩阵列表

enqueue(m_ptr);

// 打印矩阵列表

print_list(m_list);

//system("pause");

return 0;

}

m_node* create_node(int array[], int len) {

m_node* node_ptr = NULL; // 返回值

int i; // 循环变量

if (NULL != array || 0 == len) {

node_ptr = malloc(sizeof(*node_ptr)); // 动态分配内存

if (NULL != node_ptr) { // 如果分配成功则填充数据

node_ptr->data = array;

node_ptr->len = len;

node_ptr->next = NULL;

} else { // 分配内存失败，则打印错误信息后退出

fprintf(stderr, "Error: Fail to allocate "

"memories. Quit.\n");

exit(1);

}

}

return node_ptr;

}

int enqueue(m_node* node) {

int ret = FAILED; // 定义返回值

if (NULL != node) {

// 如果是列表为空，加入第1项

if (NULL == last) {

last = node;

m_list = node;

}

else { // 正常情况下

last->next = node;

last = node;

}

num++; // 节点数+1

// 如果矩阵列表中的最大长度小于当前矩阵的长度

// 那么就将当前长度赋值给列表的最大长度

if ((node->len) > max_len)

max_len = (node->len);

}

return ret;

}

void print_list(m_node* list) {

int i, j; // 循环变量

m_node* tmp; // 临时矩阵节点指针

// 行数 = 矩阵列表中长度最大的矩阵节点的长度(max_len)

// 列数 = 矩阵节点的数量(num)

for (i=0; i<max_len; i++) {

tmp = m_list;

for (j=0; j<num; j++) {

if (i >= (tmp->len))

printf("%d\t", DEFAULT_NUM);

else

printf("%d\t", tmp->data[i]);

tmp = tmp->next;

}

putchar('\n');

}

}