Algoritmos y Estructuras de Datos

Algoritmos y Estructuras de Datos
Dr. Rodrigo Paz, Dr. Mario Storti, Dr. Lisandro Dalcin
CONICET
Centro Internacional de Métodos Computacionales en IngenierÃa
September 18, 2012
Contents
1
Correspondencias con listas STL ordenadas
2
2
Árbol Ordenado Orientado: interfaz tipo STL
4
1
1
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
Correspondencias con listas STL ordenadas
#ifndef AED_MAP_H
#define AED_MAP_H
#include <list>
using namespace std;
namespace aed {
/*
/*
/*
/*
/*
/*
template<typename first_t,typename second_t> */
class pair { */
public: */
first_t first; */
second_t second; */
}; */
template<typename domain_t,typename range_t>
class map {
private:
typedef pair<domain_t,range_t> pair_t;
typedef list<pair_t> list_t;
list_t l;
/* iterator para map va a ser el mismo que para listas. */
public:
typedef typename list_t::iterator iterator;
private:
iterator lower_bound(domain_t key) {
iterator p = l.begin();
while (p!=l.end()) {
domain_t dom = p->first;
if (dom >= key) return p;
p++;
}
return l.end();
}
public:
map()
{ }
iterator find(domain_t key) {
iterator p = l.lower_bound(key);
if (p!=l.end() && p->first == key)
return p;
else return l.end();
}
2
48
49
50
51
52
53
54
55
56
57
58
59
60
range_t & operator[](domain_t key) {
iterator q = find(key);
if (q==end()) q=l.insert(key,range_t());
return q->second;
}
bool empty() { return l.begin()==l.end(); }
void erase(iterator p) { l.erase(p); }
iterator begin() { return l.begin(); }
iterator end() { return l.end(); }
void clear() { l.erase(l.begin(),l.end()); }
};
}
#endif
Listing 1: correspondencia con listas ordenadas
3
2 Árbol Ordenado Orientado: interfaz tipo STL
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
#ifndef AED_TREE_H
#define AED_TREE_H
#include <iostream>
#include <cstddef>
#include <cstdlib>
#include <cassert>
using namespace std;
namespace aed {
template<class T>
class tree {
public:
class iterator;
private:
// ----------------------------------------------------------------// -------Begin Class cell-------------------------------------class cell {
friend class tree;
friend class iterator;
T t;
cell *right, *left_child;
cell() : right(NULL), left_child(NULL) {}
};
// -------End Class cell -------------------------------------// ----------------------------------------------------------------cell *header;
// ----------------------------------------------------------------iterator tree_copy_aux(iterator nq,
tree<T> &TT,iterator nt) {
nq = insert(nq,*nt);
iterator
ct = nt.lchild(),
cq = nq.lchild();
while (ct!=TT.end()) {
cq = tree_copy_aux(cq,TT,ct);
ct = ct.right();
cq = cq.right();
}
return nq;
}
// ----------------------------------------------------------------public:
static int cell_count_m;
static int cell_count() { return cell_count_m; }
// -----------------------------------------------------------------
4
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
// -------Begin Class iterator-------------------------------------class iterator {
private:
friend class tree;
cell *ptr,*prev,*father;
iterator(cell *p,cell *prev_a,cell *f_a) : ptr(p),
prev(prev_a), father(f_a) { }
public:
iterator(const iterator &q) {
ptr = q.ptr;
prev = q.prev;
father = q.father;
}
T &operator*() { return ptr->t; }
T *operator->() { return &ptr->t; }
bool operator!=(iterator q) { return ptr!=q.ptr; }
bool operator==(iterator q) { return ptr==q.ptr; }
iterator() : ptr(NULL), prev(NULL), father(NULL) { }
iterator lchild() { return iterator(ptr->left_child,NULL,ptr); }
iterator right() { return iterator(ptr->right,ptr,father); }
// Prefix:
iterator operator++() {
*this = right();
return *this;
}
// Postfix:
iterator operator++(int) {
iterator q = *this;
*this = right();
return q;
}
};
// -------End Class iterator-------------------------------------// ----------------------------------------------------------------// ------------------------------------------------------------// constructor por defecto tree
tree() {
header = new cell;
cell_count_m++;
header->right = NULL;
header->left_child = NULL;
}
// ------------------------------------------------------------// constructor copia tree
tree<T>(const tree<T> &TT) {
if (&TT != this) {
5
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
header = new cell;
cell_count_m++;
header->right = NULL;
header->left_child = NULL;
tree<T> &TTT = (tree<T> &) TT;
if (TTT.begin()!=TTT.end())
tree_copy_aux(begin(),TTT,TTT.begin());
}
}
// ------------------------------------------------------------// destructor tree
˜tree() { clear(); delete header; cell_count_m--; }
// ------------------------------------------------------------tree<T>& operator=(const tree<T>& Q) {
clear();
tree<T> &QQ = (tree<T> &) Q;
if (QQ.begin()!=QQ.end())
tree_copy_aux(begin(),QQ,QQ.begin());
}
// ------------------------------------------------------------iterator insert(iterator p,T t) {
assert(!(p.father==header && p.ptr));
cell *c = new cell;
cell_count_m++;
c->right = p.ptr;
c->t = t;
p.ptr = c;
if (p.prev) p.prev->right = c;
else p.father->left_child = c;
return p;
}
// ------------------------------------------------------------iterator erase(iterator p) {
if(p==end()) return p;
iterator c = p.lchild();
while (c!=end()) c = erase(c);
cell *q = p.ptr;
p.ptr = p.ptr->right;
if (p.prev) p.prev->right = p.ptr;
else p.father->left_child = p.ptr;
delete q;
cell_count_m--;
return p;
}
// ------------------------------------------------------------iterator splice(iterator to,iterator from) {
assert(!(to.father==header && to.ptr));
cell *c = from.ptr;
if (from.prev) from.prev->right = c->right;
6
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
else from.father->left_child = c->right;
c->right = to.ptr;
to.ptr = c;
if (to.prev) to.prev->right = c;
else to.father->left_child = c;
return to;
}
// ------------------------------------------------------------iterator find(T t) { return find(t,begin()); }
// ------------------------------------------------------------iterator find(T t,iterator p) {
if(p==end() || p.ptr->t == t) return p;
iterator q,c = p.lchild();
while (c!=end()) {
q = find(t,c);
if (q!=end()) return q;
else c++;
}
return iterator();
}
// ------------------------------------------------------------void clear() { erase(begin()); }
// ------------------------------------------------------------iterator begin() { return iterator(header->left_child,NULL,header); }
// ------------------------------------------------------------iterator end() { return iterator(); }
// ------------------------------------------------------------void print_prev(iterator p) {
if (p==end()) return;
cout << "(" << p.ptr << "," << p.ptr->t << ")" << endl;
iterator c = p.lchild();
while (c!=end()) print_prev(c++);
}
// ------------------------------------------------------------void print_prev() { print_prev(begin()); }
// ------------------------------------------------------------void print_post(iterator p) {
if (p==end()) return;
iterator c = p.lchild();
while (c!=end()) print_post(c++);
cout << "(" << p.ptr << "," << p.ptr->t << ")" << endl;
}
// ------------------------------------------------------------void print_post() { print_post(begin()); }
// ------------------------------------------------------------void lisp_print(iterator n) {
if (n==end()) return;
iterator c = n.lchild();
bool is_leaf = c==end();
7
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
if (is_leaf) cout << *n;
else {
cout << "(" << *n;
while (c!=end()) {
cout << " ";
lisp_print(c++);
}
cout << ")";
}
}
// ------------------------------------------------------------void lisp_print() { lisp_print(begin()); }
};
// --------------------------------------------------------------template<class T>
int tree<T>::cell_count_m = 0;
// ----------------------------------------------------------------}
#endif
// -----------------------------------------------------------------
Listing 2: Árbol Ordenado Orientado
8