Форум программистов, компьютерный форум CyberForum.ru
Наши страницы

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 10, средняя оценка - 5.00
Джек
5 / 5 / 0
Регистрация: 16.08.2011
Сообщений: 77
#1

Как вы учили деревья - C++

25.11.2012, 00:39. Просмотров 1307. Ответов 24
Метки нет (Все метки)

Здравствуйте. Помогите освоить деревя на с++. Ну например как кто учил может есть какая нить литература по ним или код где хорошо все описано, или алгоритм как построить древо. В гугле полно информации но не все понятно. Я думаю многие сталкивались с такой проблемой да может есть ссылки на полезную инфу. Заранее спасибо.
0
Лучшие ответы (1)
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
25.11.2012, 00:39
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Как вы учили деревья (C++):

Как Вы учили С++ - C++
Всем привет =). Хочу немного узнать о Вас, а именно, могли бы Вы мне рассказать историю, как Вы начинали программировать на С++, что...

Как разобраться с тем, что такое указатели, стеки, деревья? - C++
Почему-то не могу осилить все эти стэки, указатели на массивы, бинарные деревья, но ведь без этого никак? Есть ли максимально подробные...

А как вы учили JavaScript? - JavaScript
Всем привет! Сейчас учу джава скрипт по урокам с сайта learn.javascript.ru, хороший учебник. Но вот задания там в конце почти каждого...

Как раньше учили новые языки? - Программирование
В общем при поиске материалов по R с минимальным опытом программирования поймал себя на этой мысли - сейчас в интернете можно практически...

Уважаемые программисты, какую книгу вы учили - C#
У меня такой вопрос к тем кто в области C# уже не первый год, и знает его на 5 Какие книги вы изучали? Пусть отвечают люди те, у кого...

Курсач по теме: Структуры данных. Двоичные деревья поиска. Красно-черные деревья - Java БД
Здравствуйте, я первокурсник, преподавателя по информатике месяца 2 не было, потом появился, дал курсач, пару занятий провел и всё. Не...

24
go
Эксперт С++
3586 / 1366 / 128
Регистрация: 16.04.2009
Сообщений: 4,528
25.11.2012, 00:48 #2
Лучший ответ Сообщение было отмечено автором темы, экспертом или модератором как ответ
Джек, листик и ручка.
4
mmd
13 / 13 / 1
Регистрация: 17.05.2012
Сообщений: 80
25.11.2012, 00:51 #3
Кормена почитай там про деревья есть
теорию графов, но это более формально
1
Джек
5 / 5 / 0
Регистрация: 16.08.2011
Сообщений: 77
25.11.2012, 01:22  [ТС] #4
Цитата Сообщение от go Посмотреть сообщение
Джек, листик и ручка.
Ну а серьйозно что то есть?
0
Croessmah
Эксперт CЭксперт С++
13420 / 7574 / 855
Регистрация: 27.09.2012
Сообщений: 18,663
Записей в блоге: 3
Завершенные тесты: 1
25.11.2012, 01:26 #5
Цитата Сообщение от Джек Посмотреть сообщение
Ну а серьйозно что то есть?
а серьезно, так и надо.
1
Джек
5 / 5 / 0
Регистрация: 16.08.2011
Сообщений: 77
29.11.2012, 01:33  [ТС] #6
Код для добавления елемента в древо правильно или нет можете проверить и указать ошибку если есть. Пожалуйста.
Вот и первый вопрос почему выводться два одинаковых числа?
C++
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
class Tree
{private:
struct Node
{Node *left;
Node *right;
int data;
Node(){left=right=0;data=0;}
};
Node *root;
public:
Tree(){root=0;}
void add(int x)
{Node *r=new Node;
if(root==NULL)
r->data=x;
root=r;
 
if(x>r->data)
r->data=x;
r->right=r;
if(x<r->data)
r->data=x;
r->left=r;
cout<<r->right->data<<endl;
cout<<r->left->data<<endl;
 
}
 
};
int main()
{Tree f;
f.add(1);
f.add(5);
f.add(6);
getch();
        return 0;
}
//---------------------------------------------------------------------------
0
I.M.
564 / 547 / 5
Регистрация: 16.12.2011
Сообщений: 1,389
29.11.2012, 01:35 #7

Не по теме:

Джек, теги-теги-теги...



Добавлено через 2 минуты
код с тегами:
C++
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
class Tree
 {private:
 struct Node
 {Node *left;
 Node *right;
 int data;
 Node(){left=right=0;data=0;}
 };
 Node *root;
 public:
 Tree(){root=0;}
 void add(int x)
 {Node *r=new Node;
 if(root==NULL)
 r->data=x;
 root=r;
 
 if(x>r->data)
 r->data=x;
 r->right=r;
 if(x<r->data)
 r->data=x;
 r->left=r;
 cout<<r->right->data<<endl;
 cout<<r->left->data<<endl;
 
 }
 
 };
 int main()
 {Tree f;
 f.add(1);
 f.add(5);
 f.add(6);
 getch();
 return 0;
 }
1
Kuzia domovenok
1891 / 1746 / 118
Регистрация: 25.03.2012
Сообщений: 5,926
Записей в блоге: 1
29.11.2012, 03:50 #8
фигурных скобок в if-ах не хватает.
приоритет операторов в выражениях cout<< может преподнести сюрприз - ставь скобки
это синтаксические ошибки.

А по сути: прохода в глубину дерева нет вообще: элемент добавляется или в корень->справа или в корень->слева или в сам корень.
четвёртого видимо не дано.
0
taras atavin
3569 / 1752 / 91
Регистрация: 24.11.2009
Сообщений: 27,619
29.11.2012, 06:54 #9
Цитата Сообщение от Джек Посмотреть сообщение
struct Node
Это тоже лучше классом с publc членами. И деструктора не хватает, который при удалении узла сотрёт всё его поддерво.

Добавлено через 2 минуты
Цитата Сообщение от Джек Посмотреть сообщение
{Node *r=new Node;
Показалось, что root=new Node;, это была бы утечка, так как корень может быть уже создан, да и не дерево, так как исключается создание потомков корня.

Добавлено через 1 минуту
Цитата Сообщение от I.M. Посмотреть сообщение
root=r;
с учётом предыдущих строк, это эквивалент root=new Node;.

Добавлено через 2 минуты
Надо в скобку, так как условие должно относиться к обоим действиям:
C++
1
2
3
4
5
if(root==NULL)
{
 r->data=x;
 root=r;
}
Добавлено через 2 минуты
Цитата Сообщение от Джек Посмотреть сообщение
if(x>r->data)
r->data=x;
r->right=r;
right всегда будет копией корня, смысл потомка в хранении собственной инфы, то есть это не потомок. Надо так:
C++
1
2
3
4
5
if(x>r->data)
{
 r->data=x;
 r->right=r;
}
.

Добавлено через 27 секунд
Цитата Сообщение от I.M. Посмотреть сообщение
if(x<r->data)
*r->data=x;
*r->left=r;
То же самое.
1
Джек
5 / 5 / 0
Регистрация: 16.08.2011
Сообщений: 77
29.11.2012, 09:12  [ТС] #10
А как проверить какое слева значение и с права. Покажите пожалуйста.
0
taras atavin
3569 / 1752 / 91
Регистрация: 24.11.2009
Сообщений: 27,619
29.11.2012, 09:15 #11
TArray.hpp:
C++
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#ifndef TARRAY_HPP_INCLUDED
#define TARRAY_HPP_INCLUDED
//=================================================================================================
template <class TItem> class TArray
{
//-------------------------------------------------------------------------------------------------
 protected:
//-------------------------------------------------------------------------------------------------
  TItem             *Data;
  size_t             Count;
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
                     TArray          (                          );
                     TArray          (TArray           &Original);
//-------------------------------------------------------------------------------------------------
                    ~TArray          (                          );
//-------------------------------------------------------------------------------------------------
  TArray             operator =      (TArray           &Original);
//-------------------------------------------------------------------------------------------------
  TItem             &operator []     (size_t            Index   );
//-------------------------------------------------------------------------------------------------
                     operator bool   (                          );
                     operator size_t (                          );
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
template
<class TItem>
TArray <TItem> ::    TArray          (                          )
{
 Data =NULL;
 Count=0;
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::    TArray          (TArray           &Original)
{
 TItem *Source;
 TItem *Target;
 if (Original.Count>0)
 {
  Data=new TItem [Original.Count];
  if (Data)
  {
   for (Source=Original.Data+Original.Count-1, Target=Data+Original.Count-1; Target>=Data; --Source, --Target)
   {
    *Target=*Source;
   }
   Count=Original.Count;
  }
  else
  {
   Count=0;
  }
 }
 else
 {
  Data =NULL;
  Count=0;
 }
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::   ~TArray          (                          )
{
 if (Data)
 {
  delete [] Data;
 }
 Data =NULL;
 Count=0;
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem>
TArray <TItem> ::    operator =      (TArray           &Original)
{
 TItem *Source;
 TItem *Target;
 if (Original.Count>0)
 {
  Data=new TItem [Original.Count];
  if (Data)
  {
   for (Source=Original.Data+Original.Count-1, Target=Data+Original.Count-1; Target>=Data; --Source, --Target)
   {
    *Target=*Source;
   }
   Count=Original.Count;
  }
  else
  {
   Count=0;
  }
 }
 else
 {
  Data =NULL;
  Count=0;
 }
 return *this;
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TItem               &
TArray <TItem> ::    operator []     (size_t            Index   )
{
 return Data[Index];
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::    operator bool   (                          )
{
 return (Count>0);
}
//-------------------------------------------------------------------------------------------------
template
<class TItem>
TArray <TItem> ::    operator size_t (                          )
{
 return Count;
}
//=================================================================================================
#endif // TARRAY_HPP_INCLUDED
, TVector.hpp:
C++
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
#ifndef TVECTOR_HPP_INCLUDED
#define TVECTOR_HPP_INCLUDED
//=================================================================================================
#include <math.h>
//=================================================================================================
class TVector
{
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
  double             x;
  double             y;
  double             z;
//-------------------------------------------------------------------------------------------------
                     TVector         (                          );
                     TVector         (TVector          &Original);
//-------------------------------------------------------------------------------------------------
                    ~TVector         (                          );
//-------------------------------------------------------------------------------------------------
  TVector            operator =      (TVector          &Original);
//-------------------------------------------------------------------------------------------------
  TVector            operator +      (TVector          &Right   );
  void               operator +=     (TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  TVector            operator -      (TVector          &Right   );
  void               operator -=     (TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  TVector            operator *      (double           &Right   );
  void               operator *=     (double           &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  TVector            operator *      (double           &Left    ,
                                      TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  TVector            operator /      (double           &Right   );
  void               operator /=     (double           &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  TVector            VectorProduct   (TVector          &Left    ,
                                      TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  void               VectorProduct   (TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  double             ScalarProduct   (TVector          &Left    ,
                                      TVector          &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  double             abs             (TVector          &Vector  );
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
TVector        ::    TVector         (                          )
{
 x=0.0;
 y=0.0;
 z=0.0;
}
//-------------------------------------------------------------------------------------------------
TVector        ::    TVector         (TVector          &Original)
{
 x=Original.x;
 y=Original.y;
 z=Original.z;
}
//-------------------------------------------------------------------------------------------------
TVector        ::   ~TVector         (                          )
{
}
//-------------------------------------------------------------------------------------------------
TVector
TVector        ::    operator =      (TVector          &Original)
{
 x=Original.x;
 y=Original.y;
 z=Original.z;
 return *this;
}
//-------------------------------------------------------------------------------------------------
TVector
TVector        ::    operator +      (TVector          &Right   )
{
 TVector Result;
 Result.x=x+Right.x;
 Result.y=y+Right.y;
 Result.z=z+Right.z;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TVector        ::    operator +=     (TVector          &Right   )
{
 x+=Right.x;
 y+=Right.y;
 z+=Right.z;
}
//-------------------------------------------------------------------------------------------------
TVector
TVector        ::    operator -      (TVector          &Right   )
{
 TVector Result;
 Result.x=x-Right.x;
 Result.y=y-Right.y;
 Result.z=z-Right.z;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TVector        ::    operator -=     (TVector          &Right   )
{
 x-=Right.x;
 y-=Right.y;
 z-=Right.z;
}
//-------------------------------------------------------------------------------------------------
TVector
TVector        ::    operator *      (double           &Right   )
{
 TVector Result;
 Result.x=x*Right;
 Result.y=y*Right;
 Result.z=z*Right;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TVector        ::    operator *=     (double           &Right   )
{
 x*=Right;
 y*=Right;
 z*=Right;
}
//-------------------------------------------------------------------------------------------------
TVector              operator *      (double           &Left    ,
                                      TVector          &Right   )
{
 TVector Result;
 Result.x=Left*Right.x;
 Result.y=Left*Right.y;
 Result.z=Left*Right.z;
 return Result;
}
//-------------------------------------------------------------------------------------------------
TVector
TVector        ::    operator /      (double           &Right   )
{
 TVector Result;
 Result.x=x/Right;
 Result.y=y/Right;
 Result.z=z/Right;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TVector        ::    operator /=     (double           &Right   )
{
 x/=Right;
 y/=Right;
 z/=Right;
}
//-------------------------------------------------------------------------------------------------
TVector              VectorProduct   (TVector          &Left    ,
                                      TVector          &Right   )
{
 TVector Result;
 Result.x=Left.y*Right.z-Left.z*Right.y;
 Result.y=Left.z*Right.x-Left.x*Right.z;
 Result.z=Left.x*Right.y-Left.y*Right.x;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TVector        ::    VectorProduct   (TVector          &Right   )
{
 TVector Result;
 Result.x=y*Right.z-z*Right.y;
 Result.y=z*Right.x-x*Right.z;
 Result.z=x*Right.y-y*Right.x;
 *this=Result;
}
//-------------------------------------------------------------------------------------------------
double               ScalarProduct   (TVector          &Left    ,
                                      TVector          &Right   )
{
 return (Left.x*Right.x+Left.y*Right.y+Left.z*Right.z);
}
//-------------------------------------------------------------------------------------------------
double               abs             (TVector          &Vector  )
{
 return sqrt(Vector.x*Vector.x+Vector.y*Vector.y+Vector.z*Vector.z);
}
//=================================================================================================
#endif // TVECTOR_HPP_INCLUDED
TMatixRow.hpp:
C++
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
#ifndef TMATIXROW_HPP_INCLUDED
#define TMATIXROW_HPP_INCLUDED
//=================================================================================================
class TMatrixRow
{
//-------------------------------------------------------------------------------------------------
 protected:
//-------------------------------------------------------------------------------------------------
  double             Items[3];
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
                     TMatrixRow      (                          );
                     TMatrixRow      (TMatrixRow       &Original);
//-------------------------------------------------------------------------------------------------
                    ~TMatrixRow      (                          );
//-------------------------------------------------------------------------------------------------
  TMatrixRow         operator =      (TMatrixRow       &Original);
//-------------------------------------------------------------------------------------------------
  double            &operator []     (size_t            Index   );
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
TMatrixRow     ::    TMatrixRow      (                          )
{
 Items[0]=0.0;
 Items[1]=0.0;
 Items[2]=0.0;
}
//-------------------------------------------------------------------------------------------------
TMatrixRow     ::    TMatrixRow      (TMatrixRow       &Original)
{
 Items[0]=Original.Items[0];
 Items[1]=Original.Items[1];
 Items[2]=Original.Items[2];
}
//-------------------------------------------------------------------------------------------------
TMatrixRow     ::   ~TMatrixRow      (                          )
{
}
//-------------------------------------------------------------------------------------------------
TMatrixRow
TMatrixRow     ::    operator =      (TMatrixRow       &Original)
{
 Items[0]=Original.Items[0];
 Items[1]=Original.Items[1];
 Items[2]=Original.Items[2];
 return *this;
}
//-------------------------------------------------------------------------------------------------
double              &
TMatrixRow     ::    operator []     (size_t            Index   )
{
 return Items[Index];
}
//=================================================================================================
#endif // TMATIXROW_HPP_INCLUDED
, TMatrix.hpp:
C++
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
#ifndef TMATRIX_HPP_INCLUDED
#define TMATRIX_HPP_INCLUDED
//=================================================================================================
#include "TMatixRow.hpp"
//=================================================================================================
class TMatrix
{
//-------------------------------------------------------------------------------------------------
 protected:
//-------------------------------------------------------------------------------------------------
  TMatrixRow         Rows[3];
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
                     TMatrix         (                          );
                     TMatrix         (TMatrix          &Original);
//-------------------------------------------------------------------------------------------------
                    ~TMatrix         (                          );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator =      (TMatrix          &Original);
//-------------------------------------------------------------------------------------------------
  TMatrixRow        &operator []     (size_t            Index   );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator +      (TMatrix          &Right   );
  void               operator +=     (TMatrix          &Right   );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator -      (TMatrix          &Right   );
  void               operator -=     (TMatrix          &Right   );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator *      (TMatrix          &Right   );
  void               operator *=     (TMatrix          &Right   );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator *      (double           &Right   );
  void               operator *=     (double           &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  TMatrix            operator *      (double           &Left    ,
                                      TMatrix          &Right   );
//-------------------------------------------------------------------------------------------------
  TMatrix            operator /      (double           &Right   );
  void               operator /=     (double           &Right   );
//-------------------------------------------------------------------------------------------------
  friend
  double             determinant     (TMatrix          &Matrix);
//-------------------------------------------------------------------------------------------------
  friend
  TMatrix            invert          (TMatrix          &Matrix  );
  void               invert          (                          );
//-------------------------------------------------------------------------------------------------
  friend
  TMatrix            transpose       (TMatrix          &Matrix  );
  void               transpose       (                          );
//-------------------------------------------------------------------------------------------------
  friend
  TVector            operator *      (TVector          &Vector  ,
                                      TMatrix          &Matrix  );
//-------------------------------------------------------------------------------------------------
  friend
  void               operator *=     (TVector          &Vector  ,
                                      TMatrix          &Matrix  );
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
TMatrix        ::    TMatrix         (                          )
{
 Rows[0][0]=1.0;
 Rows[0][1]=0.0;
 Rows[0][2]=0.0;
 Rows[1][0]=0.0;
 Rows[1][1]=1.0;
 Rows[1][2]=0.0;
 Rows[2][0]=0.0;
 Rows[2][1]=0.0;
 Rows[2][2]=1.0;
}
//-------------------------------------------------------------------------------------------------
TMatrix        ::    TMatrix         (TMatrix          &Original)
{
 Rows[0]=Original.Rows[0];
 Rows[1]=Original.Rows[1];
 Rows[2]=Original.Rows[2];
}
//-------------------------------------------------------------------------------------------------
TMatrix        ::   ~TMatrix         (                          )
{
 
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator =      (TMatrix          &Original)
{
 Rows[0]=Original.Rows[0];
 Rows[1]=Original.Rows[1];
 Rows[2]=Original.Rows[2];
 return *this;
}
//-------------------------------------------------------------------------------------------------
TMatrixRow          &
TMatrix        ::    operator []     (size_t            Index   )
{
 return Rows[Index];
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator +      (TMatrix          &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]+Right[0][0];
 Result[0][1]=(*this)[0][1]+Right[0][1];
 Result[0][2]=(*this)[0][2]+Right[0][2];
 Result[1][0]=(*this)[1][0]+Right[1][0];
 Result[1][1]=(*this)[1][1]+Right[1][1];
 Result[1][2]=(*this)[1][2]+Right[1][2];
 Result[2][0]=(*this)[2][0]+Right[2][0];
 Result[2][1]=(*this)[2][1]+Right[2][1];
 Result[2][2]=(*this)[2][2]+Right[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    operator +=     (TMatrix          &Right   )
{
 (*this)[0][0]+=Right[0][0];
 (*this)[0][1]+=Right[0][1];
 (*this)[0][2]+=Right[0][2];
 (*this)[1][0]+=Right[1][0];
 (*this)[1][1]+=Right[1][1];
 (*this)[1][2]+=Right[1][2];
 (*this)[2][0]+=Right[2][0];
 (*this)[2][1]+=Right[2][1];
 (*this)[2][2]+=Right[2][2];
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator -      (TMatrix          &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]-Right[0][0];
 Result[0][1]=(*this)[0][1]-Right[0][1];
 Result[0][2]=(*this)[0][2]-Right[0][2];
 Result[1][0]=(*this)[1][0]-Right[1][0];
 Result[1][1]=(*this)[1][1]-Right[1][1];
 Result[1][2]=(*this)[1][2]-Right[1][2];
 Result[2][0]=(*this)[2][0]-Right[2][0];
 Result[2][1]=(*this)[2][1]-Right[2][1];
 Result[2][2]=(*this)[2][2]-Right[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    operator -=     (TMatrix          &Right   )
{
 (*this)[0][0]-=Right[0][0];
 (*this)[0][1]-=Right[0][1];
 (*this)[0][2]-=Right[0][2];
 (*this)[1][0]-=Right[1][0];
 (*this)[1][1]-=Right[1][1];
 (*this)[1][2]-=Right[1][2];
 (*this)[2][0]-=Right[2][0];
 (*this)[2][1]-=Right[2][1];
 (*this)[2][2]-=Right[2][2];
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator *      (TMatrix          &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]*Right[0][0]+(*this)[0][1]*Right[1][0]+(*this)[0][2]*Right[2][0];
 Result[0][1]=(*this)[0][0]*Right[0][1]+(*this)[0][1]*Right[1][1]+(*this)[0][2]*Right[2][1];
 Result[0][2]=(*this)[0][0]*Right[0][2]+(*this)[0][1]*Right[1][2]+(*this)[0][2]*Right[2][2];
 Result[1][0]=(*this)[1][0]*Right[0][0]+(*this)[1][1]*Right[1][0]+(*this)[1][2]*Right[2][0];
 Result[1][1]=(*this)[1][0]*Right[0][1]+(*this)[1][1]*Right[1][1]+(*this)[1][2]*Right[2][1];
 Result[1][2]=(*this)[1][0]*Right[0][2]+(*this)[1][1]*Right[1][2]+(*this)[1][2]*Right[2][2];
 Result[2][0]=(*this)[2][0]*Right[0][0]+(*this)[2][1]*Right[1][0]+(*this)[2][2]*Right[2][0];
 Result[2][1]=(*this)[2][0]*Right[0][1]+(*this)[2][1]*Right[1][1]+(*this)[2][2]*Right[2][1];
 Result[2][2]=(*this)[2][0]*Right[0][2]+(*this)[2][1]*Right[1][2]+(*this)[2][2]*Right[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    operator *=     (TMatrix          &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]*Right[0][0]+(*this)[0][1]*Right[1][0]+(*this)[0][2]*Right[2][0];
 Result[0][1]=(*this)[0][0]*Right[0][1]+(*this)[0][1]*Right[1][1]+(*this)[0][2]*Right[2][1];
 Result[0][2]=(*this)[0][0]*Right[0][2]+(*this)[0][1]*Right[1][2]+(*this)[0][2]*Right[2][2];
 Result[1][0]=(*this)[1][0]*Right[0][0]+(*this)[1][1]*Right[1][0]+(*this)[1][2]*Right[2][0];
 Result[1][1]=(*this)[1][0]*Right[0][1]+(*this)[1][1]*Right[1][1]+(*this)[1][2]*Right[2][1];
 Result[1][2]=(*this)[1][0]*Right[0][2]+(*this)[1][1]*Right[1][2]+(*this)[1][2]*Right[2][2];
 Result[2][0]=(*this)[2][0]*Right[0][0]+(*this)[2][1]*Right[1][0]+(*this)[2][2]*Right[2][0];
 Result[2][1]=(*this)[2][0]*Right[0][1]+(*this)[2][1]*Right[1][1]+(*this)[2][2]*Right[2][1];
 Result[2][2]=(*this)[2][0]*Right[0][2]+(*this)[2][1]*Right[1][2]+(*this)[2][2]*Right[2][2];
 *this=Result;
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator *      (double           &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]*Right;
 Result[0][1]=(*this)[0][2]*Right;
 Result[0][2]=(*this)[0][1]*Right;
 Result[1][0]=(*this)[1][0]*Right;
 Result[1][1]=(*this)[1][2]*Right;
 Result[1][2]=(*this)[1][1]*Right;
 Result[2][0]=(*this)[2][0]*Right;
 Result[2][1]=(*this)[2][2]*Right;
 Result[2][2]=(*this)[2][1]*Right;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    operator *=     (double           &Right   )
{
 (*this)[0][0]*=Right;
 (*this)[0][1]*=Right;
 (*this)[0][2]*=Right;
 (*this)[1][0]*=Right;
 (*this)[1][1]*=Right;
 (*this)[1][2]*=Right;
 (*this)[2][0]*=Right;
 (*this)[2][1]*=Right;
 (*this)[2][2]*=Right;
}
//-------------------------------------------------------------------------------------------------
TMatrix              operator *      (double           &Left    ,
                                      TMatrix          &Right   )
{
 TMatrix Result;
 Result[0][0]=Left*Right[0][0];
 Result[0][1]=Left*Right[0][1];
 Result[0][2]=Left*Right[0][2];
 Result[1][0]=Left*Right[1][0];
 Result[1][1]=Left*Right[1][1];
 Result[1][2]=Left*Right[1][2];
 Result[2][0]=Left*Right[2][0];
 Result[2][1]=Left*Right[2][1];
 Result[2][2]=Left*Right[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
TMatrix
TMatrix        ::    operator /      (double           &Right   )
{
 TMatrix Result;
 Result[0][0]=(*this)[0][0]/Right;
 Result[0][1]=(*this)[0][2]/Right;
 Result[0][2]=(*this)[0][1]/Right;
 Result[1][0]=(*this)[1][0]/Right;
 Result[1][1]=(*this)[1][2]/Right;
 Result[1][2]=(*this)[1][1]/Right;
 Result[2][0]=(*this)[2][0]/Right;
 Result[2][1]=(*this)[2][2]/Right;
 Result[2][2]=(*this)[2][1]/Right;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    operator /=     (double           &Right   )
{
 (*this)[0][0]/=Right;
 (*this)[0][1]/=Right;
 (*this)[0][2]/=Right;
 (*this)[1][0]/=Right;
 (*this)[1][1]/=Right;
 (*this)[1][2]/=Right;
 (*this)[2][0]/=Right;
 (*this)[2][1]/=Right;
 (*this)[2][2]/=Right;
}
//-------------------------------------------------------------------------------------------------
double               determinant     (TMatrix          &Matrix)
{
 return Matrix[0][0]*(Matrix[1][1]*Matrix[2][2]-Matrix[1][2]*Matrix[2][1])-Matrix[0][1]*(Matrix[1][0]*Matrix[2][2]-Matrix[1][2]*Matrix[2][0])+Matrix[2][1]*(Matrix[1][0]*Matrix[2][1]-Matrix[1][1]*Matrix[2][0]);
}
//-------------------------------------------------------------------------------------------------
TMatrix              invert          (TMatrix          &Matrix  )
{
 TMatrix Result;
 double det;
 det=determinant(Matrix);
 Result[0][0]=(Matrix[1][1]*Matrix[2][2]-Matrix[1][2]*Matrix[2][1])/det;
 Result[0][1]=(Matrix[1][2]*Matrix[2][0]-Matrix[1][0]*Matrix[2][2])/det;
 Result[0][2]=(Matrix[1][0]*Matrix[2][1]-Matrix[1][1]*Matrix[2][0])/det;
 Result[1][0]=(Matrix[0][2]*Matrix[2][1]-Matrix[0][1]*Matrix[2][2])/det;
 Result[1][1]=(Matrix[0][0]*Matrix[2][2]-Matrix[0][2]*Matrix[2][0])/det;
 Result[1][2]=(Matrix[0][1]*Matrix[2][0]-Matrix[0][0]*Matrix[2][1])/det;
 Result[2][0]=(Matrix[0][1]*Matrix[1][2]-Matrix[0][2]*Matrix[1][1])/det;
 Result[2][1]=(Matrix[0][2]*Matrix[1][0]-Matrix[0][0]*Matrix[1][2])/det;
 Result[2][2]=(Matrix[0][0]*Matrix[1][1]-Matrix[0][1]*Matrix[1][0])/det;
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    invert          (                          )
{
 TMatrix Result;
 double det;
 det=determinant(*this);
 Result[0][0]=((*this)[1][1]*(*this)[2][2]-(*this)[1][2]*(*this)[2][1])/det;
 Result[0][1]=((*this)[1][2]*(*this)[2][0]-(*this)[1][0]*(*this)[2][2])/det;
 Result[0][2]=((*this)[1][0]*(*this)[2][1]-(*this)[1][1]*(*this)[2][0])/det;
 Result[1][0]=((*this)[0][2]*(*this)[2][1]-(*this)[0][1]*(*this)[2][2])/det;
 Result[1][1]=((*this)[0][0]*(*this)[2][2]-(*this)[0][2]*(*this)[2][0])/det;
 Result[1][2]=((*this)[0][1]*(*this)[2][0]-(*this)[0][0]*(*this)[2][1])/det;
 Result[2][0]=((*this)[0][1]*(*this)[1][2]-(*this)[0][2]*(*this)[1][1])/det;
 Result[2][1]=((*this)[0][2]*(*this)[1][0]-(*this)[0][0]*(*this)[1][2])/det;
 Result[2][2]=((*this)[0][0]*(*this)[1][1]-(*this)[0][1]*(*this)[1][0])/det;
 *this=Result;
}
//-------------------------------------------------------------------------------------------------
TMatrix              transpose       (TMatrix          &Matrix  )
{
 TMatrix Result;
 Result[0][0]=Matrix[0][0];
 Result[0][1]=Matrix[1][0];
 Result[0][2]=Matrix[2][0];
 Result[1][0]=Matrix[0][1];
 Result[1][1]=Matrix[1][1];
 Result[1][2]=Matrix[2][1];
 Result[2][0]=Matrix[0][2];
 Result[2][1]=Matrix[1][2];
 Result[2][2]=Matrix[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
void
TMatrix        ::    transpose       (                          )
{
TMatrix Result;
 Result[0][0]=(*this)[0][0];
 Result[0][1]=(*this)[1][0];
 Result[0][2]=(*this)[2][0];
 Result[1][0]=(*this)[0][1];
 Result[1][1]=(*this)[1][1];
 Result[1][2]=(*this)[2][1];
 Result[2][0]=(*this)[0][2];
 Result[2][1]=(*this)[1][2];
 Result[2][2]=(*this)[2][2];
 *this=Result;
}
//-------------------------------------------------------------------------------------------------
TVector              operator *      (TVector          &Vector  ,
                                      TMatrix          &Matrix  )
{
 TVector Result;
 Result.x=Vector.x*Matrix[0][0]+Vector.y*Matrix[1][0]+Vector.z*Matrix[2][0];
 Result.y=Vector.x*Matrix[0][1]+Vector.y*Matrix[1][1]+Vector.z*Matrix[2][1];
 Result.z=Vector.x*Matrix[0][2]+Vector.y*Matrix[1][2]+Vector.z*Matrix[2][2];
 return Result;
}
//-------------------------------------------------------------------------------------------------
void                 operator *=     (TVector          &Vector  ,
                                      TMatrix          &Matrix  )
{
 TVector Result;
 Result.x=Vector.x*Matrix[0][0]+Vector.y*Matrix[1][0]+Vector.z*Matrix[2][0];
 Result.y=Vector.x*Matrix[0][1]+Vector.y*Matrix[1][1]+Vector.z*Matrix[2][1];
 Result.z=Vector.x*Matrix[0][2]+Vector.y*Matrix[1][2]+Vector.z*Matrix[2][2];
 Vector=Result;
}
//=================================================================================================
#endif // TMATRIX_HPP_INCLUDED
, TOrientation:
C++
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
#ifndef TORIENTATION_HPP_INCLUDED
#define TORIENTATION_HPP_INCLUDED
//=================================================================================================
#include "TMatrix.hpp"
//=================================================================================================
class TOrientation
{
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
  TMatrix            TurnMatrix;
//-------------------------------------------------------------------------------------------------
                     TOrientation    (                          );
                     TOrientation    (TOrientation     &Original);
//-------------------------------------------------------------------------------------------------
                    ~TOrientation    (                          );
//-------------------------------------------------------------------------------------------------
  TOrientation       operator =      (TOrientation     &Original);
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
TOrientation   ::    TOrientation    (                          )
{
 
}
//-------------------------------------------------------------------------------------------------
TOrientation   ::    TOrientation    (TOrientation     &Original)
{
 TurnMatrix=Original.TurnMatrix;
}
//-------------------------------------------------------------------------------------------------
TOrientation   ::   ~TOrientation    (                          )
{
 
}
//-------------------------------------------------------------------------------------------------
TOrientation
TOrientation   ::    operator =      (TOrientation     &Original)
{
 TurnMatrix=Original.TurnMatrix;
 return *this;
}
//=================================================================================================
#endif // TORIENTATION_HPP_INCLUDED
TBone.hpp:
C++
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
#ifndef TBONE_HPP_INCLUDED
#define TBONE_HPP_INCLUDED
//=================================================================================================
#include <string>
//=================================================================================================
#include "TVector.hpp"
#include "TOrientation.hpp"
#include "TArray.hpp"
//=================================================================================================
class TBone
{
//-------------------------------------------------------------------------------------------------
 public   :
//-------------------------------------------------------------------------------------------------
  TBone             *Parent;
  TOrientation       Orientation;
  TVector            Position;
  std::string        Name;
//-------------------------------------------------------------------------------------------------
  TArray <TBone>     Childs;
//-------------------------------------------------------------------------------------------------
                     TBone           (                          );
                     TBone           (TBone            &Original);
//-------------------------------------------------------------------------------------------------
                    ~TBone           (                          );
//-------------------------------------------------------------------------------------------------
  TBone              operator =      (TBone            &Original);
//-------------------------------------------------------------------------------------------------
};
//=================================================================================================
TBone          ::    TBone           (                          )
{
 Parent=NULL;
 Name  ="";
}
//-------------------------------------------------------------------------------------------------
TBone          ::    TBone           (TBone            &Original)
{
 Parent     =Original.Parent;
 Orientation=Original.Orientation;
 Position   =Original.Position;
 Name       =Original.Name;
 Childs     =Original.Childs;
}
//-------------------------------------------------------------------------------------------------
TBone          ::   ~TBone           (                          )
{
}
//-------------------------------------------------------------------------------------------------
TBone
TBone          ::    operator =      (TBone            &Original)
{
 Parent     =Original.Parent;
 Orientation=Original.Orientation;
 Position   =Original.Position;
 Name       =Original.Name;
 Childs     =Original.Childs;
 return *this;
}
//=================================================================================================
#endif // TBONE_HPP_INCLUDED
.Вот такая вот коряга дерево моей мечты.
1
Джек
5 / 5 / 0
Регистрация: 16.08.2011
Сообщений: 77
29.11.2012, 09:36  [ТС] #12
Цитата Сообщение от Kuzia domovenok Посмотреть сообщение
А по сути: прохода в глубину дерева нет вообще: элемент добавляется или в корень->справа или в корень->слева или в сам корень.
четвёртого видимо не дано.
А как сделать проход в глубину дерева? Можете обьяснить как это сделатьДобавлено через 7 минут
Извените. Недавно изучаю деревья поэтому прошу что то по проще чтобы понять простое а потом и модернизировать и импровизироввать.

Добавлено через 5 минут
Вот такая вот коряга дерево моей мечты.[/QUOTE]

Простите. А можно что то проще сам код хорош но недавно изучаю деревья поэтому прошу что то близкое к элементарному.
0
taras atavin
3569 / 1752 / 91
Регистрация: 24.11.2009
Сообщений: 27,619
29.11.2012, 10:46 #13
Деревья рекурсивны, если правый потомок уже существует, а уровней может быть больше двух, то при x>root->data надо спустить добавление в поддерево:
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
protected: void add(Node *&root, int x)
{
 Node *r=new Node;
 r->data=x
 if (root==NULL)
 {
  root=r;
  return;
 }
 if (x>root->data)
 {
  add(root->right, x);
  return;
 }
 add(root->left, x);
}
public: void add(int x)
{
  add(root, x);
}
Добавлено через 1 час 7 минут
Цитата Сообщение от Джек Посмотреть сообщение
сам код хорош
Нет, он коряво-велосипедистый. Я ведь не зря обозвал это дерево корягой.
1
Джек
5 / 5 / 0
Регистрация: 16.08.2011
Сообщений: 77
30.11.2012, 00:59  [ТС] #14
Цитата Сообщение от taras atavin Посмотреть сообщение
add(root->right, x);
Оно должно возвращаться?

и
Цитата Сообщение от taras atavin Посмотреть сообщение
Node *&root
Я так понимаю указатель на адрес элемента Node?
0
MrGluck
Модератор
Эксперт CЭксперт С++
7279 / 4440 / 650
Регистрация: 29.11.2010
Сообщений: 12,022
30.11.2012, 05:58 #15
Для того, чтоб понять деревья, нужно для начала понять суть рекурсии, ну а далее - самый мудрый совет дал go, все через это проходили. Палочки и кружочки с циферками) Также, про деревья написано у Кнута (Искусство программирования). Когда я программировал АВЛ-деревья, читал еще Вирта Н. "Алгоритмы и структуры данных".

Добавлено через 2 минуты

Не по теме:

taras atavin, оформление кода конечно ацкое.

1
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
30.11.2012, 05:58
Привет! Вот еще темы с ответами:

Подскажите пожалуйста какую-нибудь книгу по изучению CSS. Что-то по чему вы сами учили например. - HTML, CSS
Здравствуйте. Подскажите пожалуйста какую-нибудь книгу по изучению CSS. Что-то по чему вы сами учили например. Спасибо :)

Деревья принятия решения (Деревья классификации) - Pascal
Доброго времени суток! Столкнулся с такой проблемой: требуется написать программу на Pascal для курсовой! Нужно создать дерево приянтия...

Как строить деревья уровней? - PHP
Кто подскажет как строить деревья уровней(скажем как на большинстве форумов). ТОесть главные нити - дочерние сообщения...

Как поставить коллайдер на деревья в Unity? - Unity, Unity3D
Привет! Народ,нужно срочно решить такую проблему: Карта не маленькая 10к на 10к.Требуется создать лес,но когда я выбираю в Terrain...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
15
Yandex
Объявления
30.11.2012, 05:58
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru