c언어 sparse matrix 질문합니다.

#include <stdio.h>
 
int main()
{
 
#if 0
희소행렬 (각각이 원소)
3 12 9
0 23 2
5 17 4
 
ordered list 차례 목록
원소들이 배열된 리스트. 각 원소들이 일정한 순서로 배열되는 것.
//열 증가
x y value
0 0 3
0 1 12
0 2 9
1 0 0
1 1 23
1 2 2
2 0 5
2 1 17
2 2 4
 
//행 증가
x y value
0 0 3
0 1 0
0 2 5
1 0 12
1 1 23
1 2 17
2 0 9
2 1 2
2 2 4
 
*희소행렬 sparse matrix: 0 이 아닌 값을 가진 원소들을 ordered list로 표현하면
원소들의 순서는 행의 인덱스가 증가하는 순서이며, 
행의 인덱스가 같은 경우 열의 인덱스가 증가하는 순서이다.
 
//----------------------------------------------------
두 행렬의 원소들의 첨자 (i,j)와 (x,y)과 주어졌을 때 
원소들의 순서를 비교하는 function은 어떻게 작성할까요?
 
A 행렬
0 2
3 5
 
i j
0 0 0
0 1 3
1 0 2
1 1 5
 
B 행렬
7 5
3 3
 
x y
0 0 7
0 1 3
1 0 5
1 1 3
 
 
#endif
 
    int matrix [3][3]= {
                        {3, 12, 9},
                        {0, 23, 2},
                        {5, 17, 4}
                       };
    int array [100][3] = {0x00,};
    int i;
    int j;
    printf("열 증가\n");
    for(i=0; i<3; i++)
    {
        for(j=0; j<3; j++)
        {
            printf("%d %d %d\n", i, j, matrix[i][j]);
        }
    }
    printf("\n");
 
    printf("행 증가\n");
    int cnt = 0;
    for(i=0; i<3; i++)
    {
        for(j=0; j<3; j++)
        {
            printf("%d %d %d\n", i, j, matrix[j][i]);
            array[cnt][0] = i;
            array[cnt][1] = j;
            array[cnt][2] = matrix[j][i];
            cnt++;
        }
    }
    printf("\n");
 
    printf("행 증가\n");
    int MAX = cnt;
    int orderA = 0;
    int orderB = 0;
    for(i=0; i<MAX; i++)
    {
        printf("%d %d %d\n", array[i][0], array[i][1], array[i][2]); 
 
        //i,j좌표와 값이 있는. 번호 순서
        if((array[i][1] == 1) && (array[i][2] == 2))
        {
            printf("i, j를 입력했을때. 원소의 순서 : i:%d j:%d 순서:%d <<--- 이 순서값을 비교하는게 답인듯 ㅇ_ㅇ;;\n", array[i][1], array[i][2], array[i][0]);
            orderA = array[i][0];
        }
 
        //x,y좌표와 값이 있는. 번호 순서
        if((array[i][1] == 3) && (array[i][2] == 1))
        {
            printf("x, y를 입력했을때. 원소의 순서 : x:%d y:%d 순서:%d <<--- 이 순서값을 비교하는게 답인듯 ㅇ_ㅇ;;\n", array[i][1], array[i][2], array[i][0]);
            orderB = array[i][0];
        }
    }
    printf("\n");
    if(orderA > orderB)
    {
        printf("순서A > 순서B 를 비교 : %d > %d\n", orderA, orderB);
    }
    else if(orderA == orderB)
    {
        printf("순서A == 순서B 를 비교 : %d == %d\n", orderA, orderB);
    }
    else
    {
        printf("순서A < 순서B 를 비교: %d < %d\n", orderA, orderB);
    }
    printf("---------------------------------------------\n");
    printf("여기서 2개의 행렬 순서 비교 완료 - 아래는 테스트 코드\n");
    printf("---------------------------------------------\n");
    printf("\n");
 
    //---------------------------------------------
    int mA [2][2]= {
                       {0, 2},
                       {3, 5}
                   };
    int mB [2][2]= {
                       {7, 5},
                       {3, 3}
                   };
    int aA [100] = {0x00,};
    int aB [100] = {0x00,};
 
    printf("두 행렬의 원소\n");
    cnt = 0;
    for(i=0; i<2; i++)
    {
        for(j=0; j<2; j++)
        {
            printf("%d %d %d %d\n", i, j, mA[j][i], mB[j][i]);
            aA[cnt] = mA[j][i];
            aB[cnt] = mB[j][i];
            cnt++;
        }
    }
    printf("\n");
 
    printf("두 행렬의 원소 순서를 비교 - 테스트\n");
    int m;
    int n;
    MAX = 4;    //원소의 갯수
    cnt = 0;
    for(m=0; m<4; m++)
    {
        for(n=0; n<4; n++)
        {
            if(aA[cnt] > aB[cnt])
            {
                printf("aA > aB : %d %d\n", aA[cnt], aB[cnt]);
            }
            else if(aA[cnt] == aB[cnt])
            {
                printf("aA == aB : %d %d\n", aA[cnt], aB[cnt]);
            }
            else
            {
                printf("aA < aB : %d %d\n", aA[cnt], aB[cnt]);
            }
            cnt++;
        }
    }
    printf("\n");
 
 
    printf("두 행렬의 원소들의 첨자 (i,j)와 (x,y)과 주어졌을 때 원소들의 값을 비교\n");
    MAX = 2;    //원소의 갯수
    cnt = 0;
    for(i=0; i<MAX; i++)
    {
        for(j=0; j<MAX; j++)
        {
            if(mA[j][i] > mB[j][i])
            {
                printf("mA > mB : %d %d [j:%d][i:%d] > [j:%d][i:%d]\n", mA[j][i], mB[j][i], j, i, j, i);
            }
            else if(mA[j][i] == mB[j][i])
            {
                printf("mA == mB : %d %d [j:%d][i:%d] > [j:%d][i:%d]\n", mA[j][i], mB[j][i], j, i, j, i);
            }
            else
            {
                printf("mA < mB : %d %d [j:%d][i:%d] > [j:%d][i:%d]\n", mA[j][i], mB[j][i], j, i, j, i);
            }
            cnt++;
        }
    }
    printf("\n");
    return 0;
}
 
//
열 증가
0 0 3
0 1 12
0 2 9
1 0 0
1 1 23
1 2 2
2 0 5
2 1 17
2 2 4
 
행 증가
0 0 3
0 1 0
0 2 5
1 0 12
1 1 23
1 2 17
2 0 9
2 1 2
2 2 4
 
행 증가
0 0 3
0 1 0
0 2 5
1 0 12
1 1 23
1 2 17
2 0 9
2 1 2
i, j를 입력했을때. 원소의 순서 : i:1 j:2 순서:2 <<--- 이 순서값을 비교하는게 답인듯 ㅇ_ㅇ;;
2 2 4
 
순서A > 순서B 를 비교 : 2 > 0
---------------------------------------------
여기서 2개의 행렬 순서 비교 완료 - 아래는 테스트 코드
---------------------------------------------
 
두 행렬의 원소
0 0 0 7
0 1 3 3
1 0 2 5
1 1 5 3
 
두 행렬의 원소 순서를 비교 - 테스트
aA < aB : 0 7
aA == aB : 3 3
aA < aB : 2 5
aA > aB : 5 3
aA == aB : 0 0
aA == aB : 0 0
aA == aB : 0 0
aA == aB : 0 0
aA == aB : 0 0
aA == aB : 0 0
aA == aB : 0 0
aA == aB : 0 0
aA == aB : 0 0
aA == aB : 0 0
aA == aB : 0 0
aA == aB : 0 0
 
두 행렬의 원소들의 첨자 (i,j)와 (x,y)과 주어졌을 때 원소들의 값을 비교
mA < mB : 0 7 [j:0][i:0] > [j:0][i:0]
mA == mB : 3 3 [j:1][i:0] > [j:1][i:0]
mA < mB : 2 5 [j:0][i:1] > [j:0][i:1]
mA > mB : 5 3 [j:1][i:1] > [j:1][i:1]