数据结构学习五（稀疏矩阵的实现，三元组）

使用三元组实现稀疏矩阵的建立、逆转、乘法。

乘法没有使用附加向量，是自己想得。有错误请谅解。性能可能没有书上介绍的好。

代码如下：（本代码只经过本人的简单测试，可能存在问题。请相信自己的能力，敢于质疑。欢迎提供更好的、更快、更简洁的代码或者方法和指出错误。在ubuntu12.04使用gcc4.6.3版本编译，在vc中如出现错误，请谅解。）

/*
*created by Reage at 2012 November 29
*description: 稀疏矩阵实现，包含乘法、逆转
*
*blog:http://blog.csdn.net/rentiansheng
*/
#include <stdio.h>
#include <stdlib.h>

#define LINE print_split(20)

typedef struct triple{
	int i,j;//行列
	int value;
}triple; 

typedef struct matrix{ 
	triple * head;
	int row,column,count;//矩阵的行、列、稀疏矩阵的元素个数
}matrix; 

/* 
*description:判断某一个位置是否已经存在元素
*parameter:
*	x:行坐标
*	y:列坐标
*	count:要查找的元素个数，如果为0表示全部，否则是count的值
*result:找到返回1，未找到返回0
*/
int find_ item (matrix *m, int x, int y, int count ){
	triple *tp = m->head;
	if ( !count || count > m->count ) count =m->count;
	int i;
	for (i  = 0; i < count - 1; i++){
		if ( tp->i == x && tp->j == y) return 1; 
		tp++;
	}
	return 0;
}

/*
*初始化稀疏矩阵
*/
void  init_matrix (matrix *m, int row, int column, int count){
//	if (m->head) free(m->head);//如果矩阵已经存在，释放原有的数据空间
	m->head = (triple *) malloc ( count * sizeof (triple));
	if (!m->head){
		printf("Allocate memory failed!application will exit.");
		exit(0);
	}
	m->row = row;
	m->column = column;
	m->count = count;

} 

/*
*输入的稀疏矩阵的可能没有按照指定的排列顺序，用此来整理
*首先按行从小到大，当行等时候按列从小到大
*/
void sort_matrix (matrix *m){
	int i, j, count = m->count;
	int loc;
	triple * tp = m->head;
	triple tmp;
	for ( i = 0; i < count-1; i++){
		loc = i;
		for (j = i+1; j < count; j++){
			if ( tp[loc].i > tp[j].i){//按行排序
				loc = j;
			}
			else if (tp[loc].i == tp[j].i && tp[loc].j > tp[j].j){
				loc = j;
			}
		}
		memcpy (&tmp, &tp[loc], sizeof(triple));
		memcpy (&tp[loc], &tp[i], sizeof(triple));
		memcpy (&tp[i], &tmp, sizeof(triple));
	}
}

/*
*创建一个使用数组存储的稀疏矩阵
*/
void creat_matrix (matrix *m){
	int row,column,count;//存储稀疏矩阵的行、列、非零元素的个数
	int i;
	int x,y;
	triple * use_triple;
	int value;
	printf ("please enter sparse matrix row,column:\n");
	scanf ("%d%d", &row, &column);
	printf ("please enter a number as the number of non-zero elements of the sparse matrix:\n");
	scanf ("%d", &count);
	init_matrix (m, row, column, count);
	use_triple = m->head;
	for (i = 0; i < count; i++){
		repeat:printf ("please enter  %d elements x and y coordinate values:", i+1);
		printf ("and a number as  element  value:");
		scanf ("%d%d%d", &x, &y, &value);
		if ( find_item (m, x, y, i+1) ) {printf("The position has been there exists an elemetn.\n");goto repeat;}
		use_triple->i = x;
		use_triple->j = y;
		use_triple->value = value;
		use_triple ++;
 	}
	sort_matrix (m);
} 

/*
*起到分割符的作用，输出count个‘—’符号
*/
void print_split (int count){
	int i;
	for (i = 0; i < count; i++)
			printf("-");
	printf("\n");
}

/*
*数据稀疏矩阵中的内容
*/
void print_matrix (matrix m){
	int len = m.count;
	int i;
	printf("\n");
	triple * sm = m.head;
	LINE;
	for (i = 0; i < len; i++){
		printf("%4d | %4d | %d\n", sm->i, sm->j, sm->value);
		sm++;
		LINE;
	}
}

/*
*description: 对稀疏矩阵逆转了，想将矩阵逆转，然后进行排序。
*paramtere：
*	sm：源稀疏矩阵
*	dm：目的稀疏矩阵
*/
void transpose_matrix1 (matrix *sm, matrix *dm){
	int i, j, count = sm->count;
	triple *dt, *st = sm->head;
	init_matrix (dm, sm->row, sm->column, sm->count);//对目的稀疏矩阵进行初始化。
	dt = dm->head
	;for (i = 0; i < count; i++){
		dt->i = st->j;
		dt->j = st->i;
		dt->value = st->value;
		sm++;
		dt++;
	}
	sort_matrix (dm);
 	
} 

/*
*description: 对稀疏矩阵逆转了，
*paramtere：
*	sm：源稀疏矩阵
*	dm：目的稀疏矩阵
*/
void transpose_matrix (matrix *sm, matrix *dm){
	int i, j;
	triple *dt, *st;
	init_matrix (dm, sm->row, sm->column, sm->count);//对目的稀疏矩阵进行初始化。
	dt = dm->head;
	for (i = 0; i < sm->column; i++){
		st = sm->head;
		for (j = 0; j < sm->count; j++){
				if ( st->j == i){
					dt->i = i;
					dt->j = st->i;
					dt->value = st->value;
					dt++;
				}
			st++; 
		}
	}

}

/*
*description:向稀疏矩阵中插入一个元素，将元素个数加一
*parameter：
*	i,j,value:要插入元素位置的行、列、值
*/
void insert_matrix (matrix *m, int i, int j, int value){
	m->count++;
	if(1 ==  m->count)
		m->head = (triple *) malloc (sizeof(triple));
	else
		m->head = (triple *) realloc (m->head, m->count * sizeof(triple));
	(m->head)[m->count-1].i = i;
	(m->head)[m->count-1].j = j;
	(m->head)[m->count-1].value = value;
}


/*
*description:矩阵的乘法
*pararmeter:
*	m1,m2:乘数和被乘数
*	result:成绩结果
*/
void multi_matrix (matrix *m1, matrix *m2, matrix *result){
	int tmp ; //保存临时计算的结果
	int i, j; //i表示计算到m2矩阵的第几列了。
	int use = 0; //表示m1正在计算当前行的第几个非零位置
	triple *tp = m1->head;//m1中非零元素的首地址
	triple *tp2 = m2->head;//m2中非零元素的首地址
	init_matrix (result, 0, 0, 0);//初始化矩阵
	if (m1->column != m2->row) return ;//无法做运算的,不满组运算条件
	if ( m1->column > m1->count || m2->row > m2->count){
		//有矩阵的成绩关系可以知，m1中的一行与m2中的一列做运算。
		//如果m1中的非零个数不满足一行，m2中的非零个数不满足一列。没有做运算的必要
		return ;
	}
	/*
	*1.首先找本行中的一个m1中非零元素tp[usue]，
	*2.查找m2[tp[use].j][i]元素是否存，存在转到第3步，否则转到第4步
	*3.计算两者的成绩加入到到tmp中。
	*4.查找同行的下一个非零元素。如存在转到第2不，不存在转到第5步
	*5.清空临时数据，进入下一个行，转到第1步。
	*/
	while ( tp < &tp[m1->count] ){//判断m1中是否还有未计算的元素，没有的话，计算结束
		for (i = 0; i < m2->column; i++){//用来控制与m2中的第几列做运算
			use = 0;//计算本行中的第一个非零元素
			tmp = 0;//计算的结果
			for (j = 0; j < m2->count; j++){//遍历m2中的所有元素，差找目标元素
				if(tp2[j].j == i && tp2[j].i == tp[use].j ){
					tmp += tp2[j].value * tp[use].value;
					if( tp[use].j == m1->column){
						break;
					} 
					if (tp >= &((m1->head)[m1->count]) || tp[use].i != tp[use+1].i ) break;
					use ++;
				}
			}
			if (tmp > 0) insert_matrix (result ,i ,j ,tmp);
		}
		//转到下一行
		while ( tp->i == tp[1].i){
			tp++;
			if ( tp >= &((m1->head)[m1->count]) ) return ;
		}
		tp++;
	}
}

void destroy_matrix (matrix *m){
	m->row = 0;
	m->column = 0;
	m->count = 0;
	free (m->head);

}