Concatenacin de vectores

Algoritmos genricos en C++

Programacin Orientada a Objeto Ing. Civil en Telecomunicaciones

Se desea concatenar dos vectores de strings

Objetos vector no poseen funcin miembro

de concatenacin

vector<string> vcat(const vector<string>& v1, const vector<string>& v2) { vector<string> result = v1; vector<string>::const_iterador iter; for (iter = v2.begin(); iter != v2.end(); ++iter) { result.push_back(*iter); } return result; }

Escribir funcin independiente vcat()

Concatenacin de vectores
Concatenacin de vectores es una operacin comn
Puede realizarse con funcin miembro

Algoritmo genrico copy()

Biblioteca estndar provee algoritmo genrico para copiar objetos usando iteradores
copy(iter1, iter2, out); Donde iter1, iter2 y out son iteradores Equivalente a
while (iter1 != iter2) *out++ = *iter1++; Excepto que copy() no modifica los iteradores

insert()
ret.insert(v1.end(), v2.begin(), v2.end());

Problema tiene solucin an ms general

Copiar elementos usando iteradores

Algoritmo genrico copy()

Separa acciones de copiar y de insertar
copy(v2.begin(), v2.end(), back_inserter(result));

Adaptador back_inserter()
Adaptador que retorna un iterador al final de un contenedor, que puede ser usado para agregar objetos al final del contenedor
Contenedor debe soportar funcin miembro

Donde back_inserter() es un adaptador de iteradores (iterator adaptor) Adaptadores extienden funciones que sobreescriben datos para que puedan agregar datos

push_back()
Funciona con string, vector y list

Errores comunes
copy(v2.begin(), v2.end(), result); copy(v2.begin(), v2.end(), result.end());

2012 Mario Medina C.

Adaptadores front_inserter() y inserter()

front_inserter(c): Adaptador que retorna un iterador al comienzo del contenedor c para insercin de datos
Contenedor debe soportar funcin miembro

Algoritmo copy_backward()
Copia elementos desde un contenedor a otro en orden inverso
copy_backward(start, end, out);

push_front()
list lo tiene, pero no string o vector

inserter(c, it): Adaptador que retorna un iterador al contenedor c para insercin de datos en la posicin it
Adaptadores estn declarados en <iterator>

Copia elementos en orden inverso desde end hasta start en la posicin comenzando en out
Equivalente a

while (start != end) *(--out) = *(--end);

Algoritmos swap() y iter_swap()

swap() intercambia objetos a y b
swap(a, b)

Algoritmo swap_ranges()
swap_ranges(start1, end1, start2) intercambia elementos entre start1 y start2 hasta llegar a end1
Equivalente a

iter_swap() intercambia objetos apuntados por iteradores a y b

swap(*a, *b)

while (start1 != end1) swap(*start1++, *start2++);

Algoritmo reverse()
reverse(start, end) invierte el orden de todos los elementos entre start y end
Equivalente a

Algoritmo reverse_copy()
reverse_copy(start, end, result) copia los valores de los elementos entre start y end a result, pero en el orden inverso
Equivalente a

while (start != end && start != -end) swap(*start++, *end);

Invierte los elementos in situ

while (start != end) *result++ = *--last; return result;

2012 Mario Medina C.

Algoritmo remove()
remove(start, end, val) elimina aquellos elementos iguales a val existentes entre los iteradores start y end
Retorna un iterador al final de la secuencia

Algoritmo remove_if()
remove_if(start, end, pred) elimina aquellos elementos entre los iteradores start y end para los cuales el predicado pred es verdadero
Retorna un iterador al final de la secuencia

Algoritmo remove_copy()
remove_copy(start, end, result, val) copia aquellos elementos diferentes a val existentes entre los iteradores start y end a partir del iterador result
Equivalente a

Algoritmo remove_copy_if()
remove_copy_if(start, end, result, pred) copia aquellos elementos entre los iteradores start y end para los cuales el predicado pred es falso a partir del iterador result
Retorna un iterador al final de la secuencia

for(; start != end; ++start) { if(!(*start == val)) *result++ = *start; } return result;

Algoritmo replace()
replace(start, end, oldv, newv) reemplaza todos los elementos entre start y end que son iguales a oldv por el valor newv
Equivalente a

Algoritmo replace_if()
replace_if(start, end, pred, newv) reemplaza todos los elementos entre start y end que cumplen con pred por el valor newv
Equivalente a

for(; start != end; ++start) { if(*start == oldv) *start = newv; }

for(; start != end; ++start) if(pred(*start)) *start = newv;

2012 Mario Medina C.

Algoritmo replace_copy()
replace_copy(start, end, result, old, newv) copia todos los elementos entre start y end que son iguales a old por el valor newv a partir de result
Equivalente a

Algoritmo replace_copy_if()
replace_copy_if(start, end, result, pred, newv) copia todos los elementos entre start y end que cumplen con pred por el valor newv a partir de result
Equivalente a

for(; start != end; ++start, ++result) *result = (*start == old) ? newv : *start;

for(; start != end; ++start, ++result) *result = (pred(*start)) ? newv : *start;

Algoritmo rotate()
rotate(start, middle, end) reordena los elementos entre start y end para que middle sea ahora el primer elemento
Rota los datos in situ

Algoritmo rotate_copy()
rotate_copy(start, middle, end, result) reordena los elementos entre start y end para que middle sea ahora el primer elemento, almacenando la secuencia rotada a partir del iterador result
Contenedor original no se ve modificado

Algoritmo unique()
unique(start, end) elimina aquellos elementos duplicados consecutivos entre start y end
Utiliza la operacin == o una funcin de

Algoritmo unique_copy()
unique(start, end, result) elimina aquellos elementos duplicados consecutivos entre start y end y copia la nueva secuencia a partir del iterador result
Utiliza la operacin == o una funcin de

comparacin dada
Si hay dos elementos duplicados no

consecutivos, unique() no los elimina!

Usar sort() antes de usar unique()

comparacin dada

2012 Mario Medina C.

Algoritmo for_each()
for_each(start, end, f) aplica la funcin f a todos los elementos entre start y end
Equivalente a

Algoritmo transform()
transform(start, end, result, op) aplica operacin op a los elementos entre start y end almacena los resultados a partir de result
Equivalente a

for(; start != end; ++start) f(*start); return f;

while (start != end) *result++ = op(*start); return result;

Algoritmo fill()
fill(start, end, val) asigna el valor val a todos los elementos entre start y end
Equivalente a

Algoritmo fill_n()
fill_n(start, n, val) asigna el valor val a n elementos a partir de start
Equivalente a

while(start != end) *start++ = val;

for(; n > 0; --n) *start++ == val;

Algoritmo generate()
generate(start, end, gen) inicializa los elementos entre start y end al valor entregado por la funcin gen
Equivalente a

Algoritmo generate_n()
generate_n(start, n, gen) inicializa n elementos a partir del iterador start al valor entregado por la funcin gen
Equivalente a

while(start != end) *start++ = gen();

Funcin gen() no recibe argumentos

for(; n > 0; --n) *start++ = gen();

Funcin gen() no recibe argumentos

2012 Mario Medina C.

Algoritmo find()
find(start, end, val) busca la primera ocurrencia de val entre start y end
Retorna iterador al elemento encontrado Equivalente a

Algoritmo find_if()
find_if(start, end, pred) retorna un iterador al primer elemento entre start y end que cumple pred
Equivalente a

for(; start != end; ++start) { if(*start == val) break; } return start;

for(; start != end; ++start) { if(pred(*start)) break; } return start;

Algoritmo find_first_of()
find_first_of(start1, end1, start2, end2) busca la primera ocurrencia de algn elemento existente entre los iteradores start2 y end2 en el rango entre start1 y end1
Retorna iterador al primer elemento

Algoritmo search()
search(start1, end1, start2, end2) busca la primera ocurrencia de la secuencia entre los iteradores start2 y end2 en el rango entre start1 y end1
Retorna iterador al primer elemento

encontrado
Si no se encuentra, retorna end1

encontrado Si no se encuentra, retorna end1

Algoritmo search_n()
search_n(start1, end1, count, val) busca la ocurrencia de count elementos sucesivos de valor val en el rango entre start1 y end1
Retorna iterador al primer elemento

Algoritmo find_end()
find_end(start1, end1, start2, end2) busca la ltima ocurrencia de la secuencia entre los iteradores start2 y end2 en el rango entre start1 y end1
Retorna iterador al primer elemento

encontrado Si no se encuentra, retorna end1

encontrado Si no se encuentra, retorna end1

2012 Mario Medina C.

Algoritmos count() y count_if()

count(start, end, val) retorna el nmero de elementos iguales a val entre los iteradores start y end count_if(start, end, pred) retorna el nmero de elementos que cumplen conel predicado pred entre los iteradores start y end

Algoritmo equal()
equal(start1, end1, start2) compara los elementos entre los iteradores start1 y end1 con aquellos a partir del iterador start2
Retorna true o false

Versin equal(start1, end1, start2, compara) utiliza funcin compara dada para realizar las comparaciones

Algoritmo mismatch()
mismatch(start1, end1, start2) compara los elementos entre start1 y end1 y aquellos a partir de start2
Retorna objeto pair(iter1,

Algoritmos min() y max()

min(a, b) retorna el mnimo entre sus dos argumentos
Usa el operador < para compararlos min(a,

iter2) conteniendo iteradores a elementos que son diferentes Tambin puede usar su propia funcin de comparacin

b, compara) retorna el mnimo entre sus dos argumentos, usando la funcin compara

max(a, b) retorna el mximo entre sus dos argumentos Usa el operador < para compararlos
max(a,

b, compara) retorna el mximo entre sus dos argumentos, usando la funcin compara

Algoritmos min_element() y max_element()

min_element(start, end) retorna un iterador al mnimo elemento entre los iteradores dados
Usa el operador < para compararlos min_element(start,

Algoritmos lower_bound() y upper_bound()

lower_bound(start, end, val) retorna un iterador al primer elemento que no es menor a val entre los iteradores dados
Datos deben estar ordenados! Puede usar el operador < una funcin

end, compara) es similar, usando la funcin compara para compararlos

compara para compararlos

max_element(start, end) es similar

upper_bound() es similar

2012 Mario Medina C.

Algoritmo binarySearch()
binarySearch(start, end, val) retorna true si existe un elemento de valor val entre los iteradores dados
Datos deben estar ordenados! Puede usar el operador < una funcin

Algoritmo sort()
sort(start, end) ordena los elementos entre start y end
Ordena los datos in situ Puede usar el operador < una funcin

compara para compararlos

compara para compararlos Si hay dos elementos iguales, no hay garanta que conserven su orden original

Algoritmo stable_sort()
stable_sort(start, end) ordena los elementos entre start y end
Ordena los datos in situ Puede usar el operador < una funcin

Algoritmo partial_sort()
partial_sort(start, middle, end) divide los elementos entre start y end usando iterador middle como criterio
Rango (start, middle) contiene los elementos

compara para compararlos Si hay dos elementos iguales, se garantiza que conservan su orden original

menores ordenados
Rango (start, end) contiene los elementos

mayores no necesariamente ordenados

Ordena los datos in situ Puede usar el operador < una funcin compara

para compararlos

Algoritmo nth_element()
nth_element(start, nth, end) divide los elementos entre start y end usando iterador nth como criterio
El n-simo elemento (nth) de la secuencia

Algoritmo partition()
partition(start, end, pred) reordena los elementos entre start y end de manera que todos los elementos para los que pred es verdadero quedan antes que aquellos para los que es falso
reordena los datos in situ

queda en la posicin correcta

Rango (start, nth) contiene los elementos

menores no necesariamente ordenados Rango (nth, end) contiene los elementos mayores no necesariamente ordenados Ordena los datos in situ

stable_partition(start, end, pred) garantiza mantener el orden anterior de los elementos

2012 Mario Medina C.

Algoritmo next_permutation()
next_permutation(start, end) reordena los elementos entre start y end de manera que el nuevo orden sea la permutacin siguiente de estos elementos
Ordenamiento se hace mediante operador < Si es posible encontrar la permutacin,

Algoritmo prev_permutation()
prev_permutation(start, end) reordena los elementos entre start y end de manera que el nuevo orden sea la permutacin anterior de estos elementos
Ordenamiento se hace mediante operador < Primera permutacin es orden ascendente ltima permutacin es orden descendente

funcin retorna true Si no es posible, funcin retorna false y reordena elementos en forma ascendente

2012 Mario Medina C.