구조체 배열 알고리즘 희소 배열 -1

 

1 개 희소 배열

용도 : 배열의 요소의 대부분은 0 또는 동일한 배열의 값이되면, 희소 배열은 배열 유지하는데 사용될 수있다 
: 처리 방법은 희소 배열 
레코드의 배열 여러 홀수 행의 총 상이한 수가 값의 
두 요소함으로써 프로그램의 크기를 줄이고, 다른 값이 작은 배열의 행에 기록 된 값을 갖는

// 11 * 11의 원래의 2 차원 배열 생성하는 예를 들면 주사위 가라
         // 0 아무런 폰 1 흑점 2 노 나타냄 
        지능 [] [] = chessArr1 새로운 새  INT [ 11 ] [ 11 ] 
        chessArr1 [ 1 [ 2 ] = 1이다. ] 
        chessArr1 [ 2 ] . 3 ] = 2 ; 
        chessArr1 [ 3. ] [ 3. ] = 1이다. ] 
        chessArr1 [ . 4 ] . (4) = 2 ;
         // 원래 2 차원 배열 얻을 
        를 들어 ( INT[] 행 : chessArr1) {
             대 ( INT의 데이터 : 행) { 
                시스템. 아웃 .printf ( " % D \ t " 데이터); 
            } 
            시스템. 아웃 ) (.println; 
        }

희소 배열 이차원 배열

원래의 2 차원 어레이를 가로 지르 합을 수득 유효 데이터의 수를
생성 할 수 합계 배열 sparseArr의 INT 세척에 따르면, 합계 + 1] [ 3],
2 차원 배열에 유효한 데이터는 희소 배열

// 성긴 배열로 2 차원 배열
         // 1 횡단 2 차원 어레이의 개수, 비 - 제로 데이터를 수득 
        하는 int SUM = 0 ;
         대 ( INT I = 0 ; I <chessArr1.length; I ++ ) {
             대 ( INT J = 0 ; J <chessArr1.length, J ++ ) {
                 IF (chessArr1 [I] [J]! = 0 ) { 
                    SUM ++ ; 
                } 
            } 
        } 
        // 2. 대응하는 희소 배열 생성 
        지능 [] [] sparseArr = 새로운 새  INT [SUM + . 1 ]3 ];
         // 희소 배열 과제 
        sparseArr [ 0 ] [ 0 ] = 11. ] 
        sparseArr [ 0 ] [ 1. ] = 11. ] 
        sparseArr [ 0 ] [ 2 ] = SUM;
         // 이차원 어레이를 가로 질러, 비제 상기 희소 배열에 저장된 값 
        의 INT COUNT = 0 ;
         대 ( INT I = 0 ; I <chessArr1.length; I ++ ) {
             대 ( INT J = 0 ; J <chessArr1.length, J ++ ) {
                IF (! chessArr1은 [I]는 [J] = 0 ) { 
                    COUNT ++ ; 
                    sparseArr [COUNT] [ 0 ] = I를, 
                    sparseArr [COUNT] [ 1. =] J; 
                    sparseArr [COUNT] [ 2 ] = chessArr1 [I] [J]; 
                } 
            } 
        } 
        // 대하여 반복의 희소 배열 
        시스템. OUT .println ( " 희소 배열이 얻어진다 : " )
         에 대한 ( INT I = 0 ; I <sparseArr.length; I ++ ) {
            대 ( INT J = 0 ; J < 3 ; J ++ ) { 
                시스템. 아웃 .printf ( " % D \ t " , sparseArr [I] [J]); 
            } 
            시스템. 아웃 ) (.println; 
        }

2 차원 어레이로 희소 배열은
원래 2 차원 배열 chessArr2 = INT [열 번호] 여기서 행] 만드는 상기 희소 배열의 첫 번째 라인 데이터의 첫 번째 행을 판독하기 위해
세척 후 배열의 다시 읽기 데이터 라인 원래의 2 차원 배열에 할당

　　　　　// 원래의 2 차원 배열로 희소 배열 복원
         // 1 제 원래 2 차원 배열을 생성하기 위해, 첫 번째 행의 데이터에있어서, 상기 희소 배열의 첫 번째 행을 판독 
        지능 [] [] = chessArr2 새로운 새  INT [sparseArr [ 0 ] [ 0 ] [sparseArr [ 0 ] [ 1. ]];
         // 2 차원 배열 생성하기 위해 희소 배열에 할당 재 판독 데이터 선 후 2 
        대를 ( INT I = 1. ; I <sparseArr.length; ++ I ) { 
            chessArr2 [sparseArr [I] [ 0 ] [sparseArr [I] [ 1. ] = sparseArr [I] [ 2 ] 
        } 
        // (가) 2 차원 어레이를 복원하여 출력 
        . 시스템 OUT의 .println를 ( "눌러 희소 배열은 2 차원 어레이로부터 회수 " )
         에 대한 ( INT [] 행 : chessArr2) {
             대 ( INT 데이터 : 행) { 
                . 시스템 OUT .printf ( " % D \ T " , 데이터) 
            } 
            . 시스템 OUT . println 메소드 (); 
        }

 파일에서 읽은 파일로 배열 한 다음

　　　　　// 성긴 배열로 2 차원 배열 직접 a.txt이 파일 판독 
        파일 파일 = 새로운 새 파일 ( " a.txt이 " ) 
        FileWriter FW = 새로운 새 FileWriter (파일)
         에 대해 ( INT가 나는 = 0 ; I <sparseArr .length; I ++ ) {
             대 ( INT J = 0 ; J < . 3 , J ++ ) { 
                fw.write (sparseArr [I] [J] + " \ T ' ); 
            } 
            fw.write ( " \ N- ' ); 
        } 
        FW () .close;
        // 이차원 배열 a.txt이 파일 판독 
        시스템. OUT .println ( " 데이터 파일로부터 얻어진! " ) 
        의 BufferedReader BR = 새로운 새 의 BufferedReader ( 새로운 새 을 FileReader ( " a.txt이 " )) ;
         INT [] [] = chessArr3 널 ; 
        문자열 라인; // 행 
        INT의 Z = 0 ;
         그동안 ((= br.readLine 라인 ())! = null의 ) { 
            Z ++ ; 
            문자열 [] TEMP = line.split (" \ t " );
            경우 (Z == 1 ) { 
                chessArr3는 = 새로운  지능 [Integer.valueOf (TEMP [ 0 ])] [Integer.valueOf (TEMP [ 1 ])]; 
            } 
            경우 (Z는> 1 ) {
                 위해은 ( INT는 전 = 0 ; I <temp.length; I ++ ) { 
                    chessArr3 [Integer.valueOf (TEMP [ 0 ])] [Integer.valueOf (TEMP [ 1 ]) = 정수. valueOf (TEMP [ 2 ]); 
                } 
            } 
        }
        대 ( INT {chessArr3 [] 행)
             에 대한 ( INT의 데이터 : 행) { 
                시스템. 아웃 .printf ( " % D \ t " 데이터); 
            } 
            시스템. 아웃 ) (.println; 
        } 
　}