Vector의 2차원 배열 표시 도움받은 곳 : http://sosal.kr/524

 

오일러 프로젝트 풀다가 아래와 같은 구조를 생성할 일이 있어

짜긴 했는데, 이런 구조를 뭐라 하는지 모르겠네요.

 

일단 TriangleTree 라고 명하고 클래스를 만들어보았습니다.

- triangleTree.h

- triangleTree.cpp

 

그리고 main.cpp

에서 함수 호출의 예를 볼 수 있습니다.

 

 

 

 

triangleTree.h

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#ifndef _TRIANGLETREE_H_
#define _TRIANGLETREE_H_
 
#include <vector>
 
class CTriangleTree
{
public :
        int init(int width) ;
        int getNext(int* pList) ;
        int destroy() ;
 
private :
        int loop() ;
 
public :
 
private :
        int m_width ;
        int m_max ;
 
        std::vector<std::vector<int> >  m_data ;
        std::vector<int>        m_direct ;
        std::vector<int>        m_value ;
 
 
        int m_status ;
        int m_row ;
        int m_col ;
 
};
 
#endif
 

 

triangleTree.cpp

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#include "triangleTree.h"
 
#include <cstdio>
 
#define LEFT    0x01
#define RIGHT   0x02
 
#define MOVE_FIRST_CHILD        0X04
#define MOVE_SECOND_CHILD       0X05
#define MOVE_PARENT             0X06
 
using namespace std ;
 
int CTriangleTree::init(int width)
{
        m_max = width ;
 
        m_status = MOVE_FIRST_CHILD ;
        m_row = 0 ;
        m_col = 0 ;
 
        m_data.clear() ;
        m_direct.clear() ;
        m_value.clear() ;
 
        m_direct.assign(width, LEFT) ;
 
        m_data.assign(width, vector<int>(width, 0)) ;
 
        for(int ii = 0; ii < m_max; ii++)
        {
                for(int jj = 0; jj <= ii; jj++)
                        m_data[ii][jj] = jj ;
        }
 
        m_value.assign(width, 0) ;
 
        return 1 ;
}
 
int CTriangleTree::getNext(int* pList)
{
        if(m_row  == m_max-1 && m_col == m_max-1)
                return 0 ;
 
        int ii ;
        int flagBreak = 0 ;
 
        while(1)
        {
                if(flagBreak)
                        break ;
 
                switch(m_status)
                {
                case MOVE_FIRST_CHILD :
                        m_row++ ;
                        m_value[m_row] = m_data[m_row][m_col] ;
                        m_direct[m_row - 1] = LEFT ;
 
                        m_status = (m_row < m_max-1) ? MOVE_FIRST_CHILD : MOVE_SECOND_CHILD ;
 
                        if(m_row == m_max-1)
                        {
                                for(ii = 0; ii <= m_row ; ii++)
                                        pList[ii] = m_value[ii] ;
                                return 1 ;
                        }
                        break ;
 
                case MOVE_SECOND_CHILD :
                        m_col++ ;
                        m_value[m_row] = m_data[m_row][m_col] ;
 
                        m_direct[m_row - 1] = RIGHT ;
                        m_status = (m_row < m_max-1) ?  MOVE_FIRST_CHILD : MOVE_PARENT ;
 
                        if(m_row == m_max-1)
                        {
                                for(ii = 0; ii <= m_row ; ii++)
                                        pList[ii] = m_value[ii] ;
                                return 1 ;
                        }
                        break ;
                case MOVE_PARENT :
                        if(m_direct[m_row-1] == RIGHT)
                                m_col-- ;
                        m_row-- ;
 
                        if(m_row == 0)
                        {
                                m_status = MOVE_SECOND_CHILD ;
                                m_row++ ;
                                break ;
                        }
 
                        m_status = (m_direct[m_row-1] == LEFT) ?  MOVE_SECOND_CHILD : MOVE_PARENT ;
                        break ;
                }
        }
 
        return 0 ;
}
 
int CTriangleTree::destroy()
{
        m_data.clear() ;
        m_direct.clear() ;
        m_value.clear() ;
 
        return 1 ;
}
 

 

main.cpp

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include "triangleTree.h"
 
#include <cstdio>
 
using namespace std ;
 
int main()
{
        CTriangleTree triTree ;
 
        const int MAX = 5 ;
 
        triTree.init(MAX) ;
        int value[MAX] ;
 
        while(1)
        {
                if(!triTree.getNext(value))
                        break ;
 
                for(int ii = 0; ii < MAX; ii++)
                        printf("%d ", value[ii]) ;
                printf("\n") ;
 
        }
 
        return 1 ;
}
 

 

+ Recent posts