Arreglos asociativos

Es una estructura de datos que almacena un par clave-valor (key-value), donde la clave
representa un identificador (generalmente único) y el valor consiste en el dato a almacenar.
También se conoce como map, tabla de símbolos ó diccionario. Un arreglo asociativo se
considera una colección donde siempre se añaden y remueven elementos del tipo clave-valor.
Igualmente, es posible modificar el valor de un elemento de la colección dada la clave. Así, existe
una forma de direccionamiento de una posición de la colección dada una clave (lookup).

La utilidad de estructuras de arreglos asociativos deriva básicamente en el almacenamiento de

datos basados en operaciones de búsqueda, eliminación e inserción. Las operaciones comunes en
este tipo de estructura son:
Insert: Agrega un par (key, value) a la colección, realizando una asociación de la clave con su
valor asociado. Los parámetros de está función son key y value.

Ejemplo en C++
//Declaramos estructura map que almacena una clave, valor
map<string, long> directorio;

//insertar elementos en un map

directorio.insert(std::pair<string,long>("D",100));

Modify: Reemplaza el valor de uno de los pares (key,value) existentes en la colección, cambiando
el valor almacenado en cierto key. Los parámetros de está función son key y value.

//Declaramos estructura map que almacena una clave, valor

map<string, long> directorio;
directorio["A"]=1234567; /*por la clave a almaceno el valor 1234567 (A,123567)*/
directorio["A"]=888; //modificamos el valor del directorio A;

Delete: Elimina el valor de uno de los pares (key,value) existentes en la colección. Solo requiere el
parámetro key.

PANTALLA01 PANTALLA02
map<string, long> directorio; if(directorio.find(name)!=directorio.end()){
directorio["C"]=3456789; cout << "El numero de telefono para " << name
map.erase(“C”); << " es " <<directorio[name] << "\n";
}else{
name="C"; cout << "No se encuentra el valor especificado " << name << "\n";
system("pause");
return 0;
}

Lookup: Busca el valor (si existe) que está asociado a cierto valor de key. El parámetro de esta
función es el valor de key y retorna value. Si no se encuentra un valor asociado, entonces deber
retornar un valor que indique nulo (o una excepción).

Ejemplo con map en C++ CON ESTRUCTURA MAP. DECIRLES QUE LO CORRAN.
#include<iostream>
#include<iostream> directorio["A"]=888; /*por la clave a almaceno el valor
#include<map> 1234567 (A,123567)*/
#include<string> name="A";
if(directorio.find(name)!=directorio.end()){
using namespace std; cout << "El numero de telefono para " << name
<< " es " <<directorio[name] << "\n";
int main(){ }

//estructura map que almacena una clave, valor //Operaciones de borrado sobre las listas
 map<string, long> directorio;
//OPCION 1: Utilizando un iterador
map<string, long>::iterator it;
//seteamos algunos valores para la estructura directorio
de tipo map it=directorio.find("A");
directorio["A"]=1234567; /*por la clave a almaceno el directorio.erase(it);
valor 1234567 (A,123567)*/
directorio["B"]=9876543; /*almaceno de esta forma( if(directorio.find(name)!=directorio.end()){
B,9876543)*/ cout << "El numero de telefono para " << name
directorio["C"]=3456789; /*almaceno de esta forma( << " es " <<directorio[name] << "\n";
C,3456789)*/ }else{
cout << "No se encuentra el valor especificado " <<
string name="A"; name << "\n";

/*Verificamos si el elemento A se encuentre en alguna }

de las claves definidas anteriormente*/
if(directorio.find(name)!=directorio.end()){ //OPCION02: Borrando solo por la clave
cout << "El numero de telefono para " << name directorio.erase("C");
<< " es " <<directorio[name] << "\n";
}else{ name="C";
cout << "No se encuentra el valor especificado " << if(directorio.find(name)!=directorio.end()){
name << "\n"; cout << "El numero de telefono para " << name
return 0; << " es " <<directorio[name] << "\n";
} }else{
//insertar elementos en un map cout << "No se encuentra el valor especificado " <<
directorio.insert(std::pair<string,long>("D",100)); name << "\n";
name="D"; system("pause");
return 0;
if(directorio.find(name)!=directorio.end()){ }
cout << "El numero de telefono para " << name cout << endl;
<< " es " <<directorio[name] << "\n"; system("pause");
} }

Generalmente, la implementación en diversos lenguajes de programación de esta estructura de

datos se conoce como map o hash. Un ejemplo de arreglos asociativos se puede observar en una
empresa de alquiler de autos:
{“Ford BRD052” : “Luis Martinelli”}
{“Volkswagen AFV867” : “Luis Martinelli”}
{“Ford AAR309” : “Luisa Martinelli”}

Existe otra estructura de datos que representa una generalización del arreglo asociativo llamada
multimap o multihash y permite que sea asociado más de un valor para una clave dada.

VER EJEMPLO DE MULTIMAP EN C++ (SIGUIENTE PÁGINA)

Ejemplo de Multimap en C++

#include<iostream> int main(){
#include<map> map<Name, Number>directorio;
#include<string> directorio.insert(pair<Name,
Number>(Name("T"),Number("555-4444")));
using namespace std; directorio.insert(pair<Name,
Number>(Name("T"),Number("555-3333")));
class Name{ directorio.insert(pair<Name,
char str[40]; Number>(Name("T"),Number("555-2222")));
directorio.insert(pair<Name,
public: Number>(Name("T"),Number("555-1111")));
Name(){
strcpy(str,""); char str[80]="T";
} map<Name, Number>::iterator p;
 Name(char *s){
strcpy(str,s); p=directorio.find(Name(str));
} if(p!=directorio.end()){
char *get(){ cout << "Phone number: " << p->second.get();
return str; }else{
} cout << "Name not in directory.\n";
}; }
cout << endl;
bool operator<(Name a , Name b){ system("pause");
return strcmp(a.get(), b.get())<0; return 0;
} }

class Number{
char str[80];
public:
Number(){
strcmp(str, "");
}
Number(char *s){
strcpy(str,s);
}
char *get(){
return str;
}
};

CONJUNTO SET Y MULTISET

Conjunto
Un conjunto (set) es un tipo de dato que almacena valores sin un orden en particular sin repetición. Un set es
la implementación matemática de un conjunto finito considerando sus operaciones (unión, intersección,
diferencia y subconjunto). Del mismo modo, la estructura de datos conjunto puede ser estática (inmutable) o
dinámica (mutable). La primera de éstas permite hacer consultas para un valor dado y determinar si
pertenecen o no a un conjunto. La segunda permite las mismas operaciones que la estática añadiendo
inserción y eliminación. Un conjunto puede ser de cualquier tipo de dato e implementado de forma contigua
en memoria (arreglos) o de forma dispersa (apuntadores). Las operaciones básicas de una estructura
conjunto se pueden resumir en: isEmpty, size, insert, delete, add y elementOf.

Ejemplo de Conjunto SET EN C++

#include<iostream> setStr.insert(s);
#include<set> s="R";
#include<string>
setStr.insert(s);
using namespace std; s="Toto";
setStr.insert(s);
int main(){
for(set<string>::const_iterator p=setStr.begin();
set<string> setStr; p!=setStr.end();p++)
string s="B"; cout << *p << endl;

setStr.insert(s); system("pause");
s="So"; }

EJEMPLO DE UN CONJUNTO SET CON ARREGLOS - OJO CON ESTE EJERCICIO

#include<iostream> bool Set::Equal (Set * set)

#include<set> {
using namespace std; if (card != set -> card) return false;
const int maxCard = 16; for (int i=0; i<card; ++i)
//bool {false, true}; if(!set->Member(elems[i]))
enum ErrCode {noErr,overflow}; return false;
return true;
class Set { }
int elems[maxCard]; /*Equal*/
int card;
public: void Set ::Print()
void EmptySet() {card=0;} {
bool Member (int); cout<<"{";
ErrCode AddElem (int); for(int i =0; i< card-1;++i)
void RmvElem (int); cout<<elems[i] <<",";
void Copy (Set *); if (card >0)
bool Equal(Set *); cout<< elems[card-1];
void Print(); cout<<"}\n";
void Intersect (Set *,Set *); }
ErrCode Union (Set *,Set *); /*Print*/
};

bool Set ::Member (int elem) main()

{ {
for(int i=0; i< card; ++i) Set s1,s2,s3;
if (elems [i] == elem) s1.EmptySet(); s2.EmptySet(); s3.EmptySet();
return true; s1.AddElem(10); s1.AddElem(20);
return false; s1.AddElem(30);s1.AddElem(40);
} s2.AddElem(30); s2.AddElem(50);
/*Member */ s2.AddElem(10);s2.AddElem(60);
cout<<"s1="; s1.Print();
ErrCode Set ::AddElem (int elem) cout<<"s2="; s2.Print();
{ s2.RmvElem(50);
for( int i=0; i<card; ++i) cout<<"s2 - {50}= "; s2.Print();
if (elems[i] == elem) return noErr; if(s1.Member(20))
if (card< maxCard){ cout<<"20 is in s1\n";
elems[card++] = elem; return noErr; //s1.Intersect(&s2,&s3);
} else cout<<"s1 intsec s2 ="; s3.Print();
return overflow; //s1.Union(&s2,&s3);
} cout<<"s1 union s2="; s3.Print();
/*AddElem*/ if (!s1.Equal(&s2))
cout<<"s1/= s2 \n";
void Set ::RmvElem(int elem) system("pause");
{ }
for (int i=0; i< card;++i)
if (elems[i] = elem){
for (; i< card-1; ++i)
elems[i]= elems [i+1];
--card;
}
}
/*RmvElem*/

//void Set ::Copy (Set *,Set set)

void Set ::Copy (Set* set)

{
for(int i=0; i<card; ++i)
set->elems[i] = elems [i];
set->card = card;
}
/*Copy*/
HAGAN UNA CORRIDA DE ESTE EJERCICIO E IMPLEMENTEN LAS DEMÀS
FUNCIONALIDADES QEU FALTEN
HAGAN ESTE EJERCICIO CON PUNTEROS

Existe una estructura de datos llamada multiset o bag la cual es una generalización del tipo set. La diferencia
radica en que permite repetir valores. De esta forma, es posible considerar dos elementos iguales como un
solo elemento y manteniendo un contador de dicho elemento ó considerados equivalentes y almacenarlos de
forma distinta y única. Dependiendo de la implementación de conjunto, se pueden establecer relaciones de
equivalencia dentro de los conjuntos.

Ejemplo de Conjunto MULTISET EN C++

#include<iostream> call1.insert(1);
#include<algorithm> call1.insert(6);
#include<set> call1.insert(2);
#include<iterator> call1.insert(5);

using namespace std; //Itera sobre los elementos e imprimirlos

intSet::iterator pos;
int main(){
for(pos=call1.begin(); pos!=call1.end();++pos){
typedef multiset<int, greater<int> > intSet; cout << *pos << ' ' ;
intSet call1; }
cout << endl;
call1.insert(4); system("pause");
call1.insert(3); }
call1.insert(5);
 ESTRUCTURA DEQUE

Cola Doblemente Terminada

Una estructura de cola doblemente terminada, o abreviada como deque (double-ended queue) y
a veces llamada lista enlazada cabeza-cola, es una generalización de cola donde los elementos
pueden ser insertados o removidos por delante (head) o por detrás (tail). Esta estructura de datos
puede contener restricciones en las operaciones de insertar/borrar. De hecho, la estructura cola y
pila derivan de estas restricciones.
Las operaciones de la estructura deque son: insertar un elemento por detrás, insertar un elemento
por delante, eliminar el último elemento, eliminar el primer elemento, extraer/procesar el
primer/último elemento.
La implementación común de una estructura de que es empleando una arreglo dinámico (arrays
deques) y una lista doblemente enlazada.

Ejemplo con C++ implementando primitivas

#include <iostream.h>
#include <conio.h>
// using namespace std;
typedef char DATA_TYPE;

struct nodo {
DATA_TYPE data;
nodo *next, *prev;
};

class DDqueue {
int itemsize, items;
nodo *cola, *cabeza;

public:
// constructor
DDqueue() : cola(NULL), cabeza(NULL), items(0), itemsize(sizeof(DATA_TYPE)) {}

// destructor
~DDqueue() {}

/* agregar componente en la parte trasera de la lista */

DATA_TYPE put_back(DATA_TYPE valor)
{
nodo *temp;

temp = new nodo;

if (temp == NULL) return -1;

temp->data = valor;

items ++;
if (cabeza == NULL )
{
temp->next = NULL;
temp->prev = NULL;
cabeza = temp;
cola = temp;
} else
{
cola->next = temp;
 temp->prev = cola;
cola = temp;
cola->next = NULL;
}
return valor;
}

/* agregar componente en la parte frontal de la lista */

DATA_TYPE put_front(DATA_TYPE valor)
{
nodo *temp;

temp = new nodo;

if (temp == NULL) return -1;

temp->data = valor;

items ++;
if (cabeza == NULL )
{
temp->next = NULL;
temp->prev = NULL;
cabeza = temp;
cola = temp;
} else
{
cabeza->prev = temp;
temp->next = cabeza;
cabeza = temp;
cabeza->prev = NULL;
}
return valor;
}

// regresa true si la lista está vacia

int empty() { return items == 0; }
/* retirar elemento de la parte frontal lista */
DATA_TYPE get_front()
{
nodo *temp;
DATA_TYPE d;

if ( empty() ) return -1;

items --;
d = cabeza->data;
temp = cabeza->next;
if (cabeza) delete cabeza;
cabeza = temp;
return d;
}

/* retirar elemento de la parte trasera de la lista */

DATA_TYPE get_back()
{
nodo *temp;
DATA_TYPE d;

if ( empty() ) return -1;

items--;
d = cola->data;
 temp = cola->prev;
if (cola) delete cola;
cola = temp;
return d;
}

}; // fin de la clase DDqueue

/* punto de prueba */
int main()
{

system("cls");

DDqueue s;
DATA_TYPE d;

// insertando elementos en la parte trasera

for (d='A'; d<='Z'; d++) s.put_back(d);

// insertando en la parte delantera

for (d=9; d>=0; d--)s.put_front(d+'0');

// vaciando la lista
while ( ! s.empty())
cout << (DATA_TYPE)s.get_front() << " ";

cout << "\nPara terminar presione <Enter>...";

cin.get();
return 0;
}

Ejemplo de deque implementado utilizando las funciones de C++

Las operaciones que se aplican sobre la pila son de tipo LIFO, es decir el ultimo elemento en salir
es el ultimo en ingresar
Soporta las funciones empty, size, front, top, push, y pop.
Empty: para verificar si la pila esta vacia o no
Size: tamaño de la pila
Top: Obtiene el tope de la pila
Push: inserta elemento en el tope de la pila
Pop: quita un elemento del tope de la pila

Elementos individuales pueden ser accesados por su posición(índice)

Se puede iterar sobre todos los elementos en cualquier orden
Los elementos pueden ser añadidos o eliminados eficientemente de los extremos
Los elementos no se almacenan en espacios contiguos de la memoria(us muchos bloques)

PANTALLA 01 PANTALLA 02
#include <iostream.h> cout << "IMPRESION 01" << endl;
#include <deque.h> cout << endl;

using namespace std; for(int i=0; i<animales.size();i++){

/** cout << animales[i] << endl;
* Cola doblemente terminada: Implementación en C++ }
**/
 cout << endl;
int main(){
deque<string> animales;
cout << "IMPRESION 02" << endl;
animales.push_back("-Perro"); cout << endl;
animales.push_back("-Gato"); for(int i=0; i<animales.size();i++){
animales.push_back("-Cerdo"); cout << animales.at(i) << endl;
animales.push_back("-Mapache"); }
cout << endl;
animales[2]="-Gusano"; system("pause");

return 0;
}