C - Initializing a Sparse Matrix

struct Node
{  
    long rowIndex;
    long columnIndex;
    double value;
    struct Node* rowPtr;
    struct Node* colPtr;
};
typedef struct Node Node;

struct Matrix
{
    long dimension;
    Node** rowList;
    Node** columnList;
};

void initializeMatrix(Matrix** M, long* dimension, FILE* in) {
	(*M)->rowList = (Node**)malloc(*dimension*sizeof(Node*));
	(*M)->columnList = (Node**)malloc(*dimension*sizeof(Node*));
	int i;
	for (i=0; i<*dimension; i++) {
		(*M)->rowList[i] = NULL;
		(*M)->columnList[i] = NULL;
	} 
}

int main(int argc, char* argv[])
{
    FILE* in;
	long dimension, row_index, column_index;
	in = fopen(argv[1], "r");
	fscanf(in, "%ld", &dimension);
    double value;
    Matrix* M = malloc(sizeof(Matrix));
  
    initializeMatrix(&M, &dimension,in);

    while (fscanf(in, "%ld  %ld  %lf", &row_index, &column_index, &value) == 3) {
		insertNode(&M, row_index, column_index, value);
    }
}

#include "matrix.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void initializeMatrix(Matrix** M, long* dimension, FILE* in) {
	(*M)->rowList = (Node**)malloc(*dimension*sizeof(Node*));
	(*M)->columnList = (Node**)malloc(*dimension*sizeof(Node*));
	int i;
	for (i=0; i<*dimension; i++) {
		(*M)->rowList[i] = NULL;
		(*M)->columnList[i] = NULL;
	} 
}
void insertNode(Matrix** M, long row_index, long column_index, double value) {
	Node* ptr = (Node*)malloc(sizeof(Node)); 
	ptr->value = value; /* initialize all properties of node */
	ptr->rowIndex = row_index;
	ptr->columnIndex = column_index;
	if ((*M)->rowList[row_index] == NULL) { /* index is empty */
		ptr->rowPtr = NULL;
		(*M)->rowList[row_index] = ptr;
	}
	if ((*M)->columnList[column_index] == NULL) { 
		ptr->colPtr = NULL;
		(*M)->columnList[column_index] = ptr;
	}
	if ((*M)->rowList[row_index]->columnIndex > column_index) { /* insert node to front */
		ptr->colPtr = (*M)->rowList[row_index];
		(*M)->rowList[row_index] = ptr;
	}
	if ((*M)->columnList[column_index]->rowIndex > row_index) { 
		ptr->rowPtr = (*M)->rowList[row_index];
		(*M)->columnList[column_index] = ptr;
	}
	if ((*M)->rowList[row_index]->columnIndex < column_index) { /* insert node in order */
		Node* rowptr = (Node*)malloc(sizeof(Node));
		rowptr = (*M)->rowList[row_index];
		while (rowptr->colPtr != NULL && rowptr->columnIndex < column_index) {
			rowptr = rowptr->colPtr;
		}
		if (rowptr->colPtr == NULL) {
			rowptr->colPtr = ptr;
			free(rowptr);
		}
		else { /* node already exists */
			printf("Node already exists!");
			free(ptr);
			free(rowptr);
		}
	}
	if ((*M)->columnList[column_index]->rowIndex < row_index) {
		Node * colptr = (Node*)malloc(sizeof(Node));
		colptr = (*M)->columnList[column_index];
		while (colptr->rowPtr != NULL && colptr->rowIndex < row_index) {
			colptr = colptr->rowPtr;
		}
		if (colptr->rowPtr == NULL) {
			colptr->rowPtr = ptr;
			free(colptr);
		}
		else { /* Node already exists! */
			printf("Node already exists!");
			free(ptr);
			free(colptr);
		}
	}
}
void printSubMatrix(Matrix* M, long beginrow, long endrow, long begincol, long endcol) {
	long i = beginrow;
	Node* ptr = (Node*)malloc(sizeof(Node));
	ptr->columnIndex = begincol;
	for (i; i<endrow; i++) {
		printf("\n");
		if (M->rowList[i] != NULL) {
			ptr = M->rowList[i];
			while (ptr->columnIndex <= endcol) {
				printf("%lf ", ptr->value);
				ptr = ptr->colPtr;
			}
		}
	}
	free(ptr);
}