Hi, I'm new here so I'm not sure if this is the right place to ask for homework help. Sorry if it's not proper :) This is from my Data Structures class. I'm just about done with the assignment but it's giving me memory leaks and I'm not sure what's up. I used Visual Leak Detector and it says they're coming from my root and newList lists in the advancedSplit() function (lines 34-42), as well as a couple other places. I do call functions to deallocate the memory though, so I'm not sure if I'm doing it incorrectly. I'm including my main(), advancedSplit(), and the functions I use to delete memory. Any help is appreciated, thanks for your time :)

```
int main( void )
{
// Local Definitions
MATRIX *matrix;
MATRIX* newMatrix;
MATRIX* advMatrix;
// Statements
// matrix = buildRandomMatrix( 6, 6 );
// matrix = buildRandomMatrix( 3, 3 );
// matrix = buildRandomMatrix( 2, 2 );
matrix = buildRandomMatrix( 1, 1 );
// matrix = buildRandomMatrix( 0, 0 );
// matrix = buildRandomMatrix( -10, -10 );
// matrix = buildRandomMatrix( 5, 6 );
if( !matrix )
printf("Invalid sizes!\n");
else
{
printf("ORIGINAL MATRIX:\n\n");
printMatrix( matrix );
newMatrix = split(matrix); // must be changed
advMatrix = advancedSplit(matrix);
printf("\nNEW LISTS:\n\n");
printMatrix(newMatrix);
printMatrix(advMatrix);
deleteMatrix(matrix);
deleteMatrix(newMatrix);
deleteMatrix(advMatrix);
printf( _CrtDumpMemoryLeaks() ? "Memory Leak\n" : "No Memory Leak\n");
}
return 0;
}
```

```
/* ********************************************************** */
/* ********************************************************** */
/* ********************************************************** */
/* =======================================================
This function splits a matrix along its left-right diagonal and
creates a new matrix containing three linked lists: one from the data
above the diagonal, one from the data on the diagonal, and one
containing the data below the diagonal.
PRE: MATRIX* - a pointer to the matrix to be split
POST: Returns a new matrix with three linked lists
*/
MATRIX* advancedSplit( MATRIX *matrix ) // must be changed
{
MATRIX* newMatrix; // Stores the two linked lists
NODE* pCurr; // Current node for matrix
NODE* newList1; // Linked list with data above diagonal
NODE* newList2; // Linked list with data below diagonal
NODE* newList3; // Linked list with data on diagonal
NODE* root1; // Head of the first linked list
NODE* root2; // Head of the second linked list
NODE* root3; // Head of the third linked list
int colDecrement; // Decrements the number of nodes to be read each row
int rowIndex = 0;
int elemCount = 0;
int elemCount2 = 0;
int elemCount3 = 0;
// initialize newMatrix
newMatrix = (MATRIX *) malloc(sizeof(MATRIX));
newMatrix->m = (NODE **) calloc( matrix->rows, sizeof(NODE *));
// initialize newList1 and newList2 as well as root1 and root2
newList1 = (NODE*) malloc(sizeof(NODE*));
root1 = (NODE*) malloc(sizeof(NODE*));
root1->link = 0;
newList2 = (NODE*) malloc(sizeof(NODE*));
root2 = (NODE*) malloc(sizeof(NODE*));
root2->link = 0;
newList3 = (NODE*) malloc(sizeof(NODE*));
root3 = (NODE*) malloc(sizeof(NODE*));
root3->link = 0;
// This creates a list of data from the upper portion
pCurr = matrix->m[rowIndex]->link;
for (colDecrement = 2; colDecrement <= matrix->cols && rowIndex != matrix->rows; colDecrement++)
{
int colCount = colDecrement;
for (elemCount; colCount <= (matrix->cols); colCount++, elemCount++) {
newList1->data = pCurr->data;
if (pCurr->link != NULL) // Check to see if we're at the end of the list
pCurr = pCurr->link;
if (colDecrement == matrix->cols && rowIndex == matrix->rows - 2)
newList1->link = 0; // link is NULL if we're at the last node
else
newList1->link = (NODE*) malloc(sizeof(NODE*));
if (colCount == 2)
root1 = newList1; // point root1 to the head of newList1
newList1 = newList1->link;
}
rowIndex++;
pCurr = matrix->m[rowIndex]->link;
if (rowIndex < matrix->rows - 1) {
for (int i = 0; i < rowIndex; i++)
pCurr = pCurr->link;
}
}
// This creates a list of data from the lower portion
rowIndex = 1;
int increment = matrix->cols - 1;
for (rowIndex = 1; rowIndex < matrix->rows; rowIndex++, increment--)
{
pCurr = matrix->m[rowIndex];
for (int colCount = 0; colCount < (matrix->cols) - increment; colCount++) {
newList2->data = pCurr->data;
pCurr = pCurr->link;
if (rowIndex == matrix->rows - 1 && colCount == matrix->cols - 2)
newList2->link = 0;
else
newList2->link = (NODE*) malloc(sizeof(NODE*));
if (rowIndex == 1)
root2 = newList2; // point root to the head of newList1
newList2 = newList2->link;
elemCount2++;
}
}
// This creates a list of data from the diagonal
rowIndex = 0;
for (rowIndex = 0; rowIndex < matrix->rows; rowIndex++)
{
pCurr = matrix->m[rowIndex];
for (int i = 0; i < rowIndex; i++) {
pCurr = pCurr->link;
}
newList3->data = pCurr->data;
if (rowIndex == (matrix->rows - 1))
newList3->link = 0;
else
newList3->link = (NODE*) malloc(sizeof(NODE*));
if (rowIndex == 0)
root3 = newList3; // point root to the head of newList1
newList3 = newList3->link;
elemCount3++;
}
newList1 = root1;
newList2 = root2;
newList3 = root3;
newMatrix->rows = 3;
newMatrix->cols = elemCount;
newMatrix->m[0] = newList1;
newMatrix->m[1] = newList2;
newMatrix->m[2] = newList3;
// Deallocate memory
freeList(newList1);
freeList(newList2);
freeList(newList3);
freeList(root1);
freeList(root2);
freeList(root3);
return newMatrix;
}
```

```
void deleteMatrix( MATRIX* matrix )
{
for( int r = 0; r < matrix->rows; r++ )
freeList(matrix->m[r]);
}
void freeList( NODE* head )
{
NODE* tmp;
while (head)
{
tmp = head;
head = head->link;
tmp = 0;
free(tmp);
}
free (head);
}
```