PILA

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, 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

Aplicaciones en la vida real: Implementar la operación de deshacer en un editor de

texto(CTRL+Z)

EJEMPLO EN C++

1 2
#include <iostream.h> stack<int>::size_type i;
#include <stack.h> //stack<int> i;

using namespace std; i=pila01.size(); //cantidad de elementos de la pila

cout << "Tamano de la pila es:" <<i <<endl;
int main(){ cout << endl;

stack<int> pila01, pila02;

i=pila01.top(); //obtenemos el elemento que esta en el tope
if(pila01.empty()){ de la pila
cout << "La pila esta vacia. Tiene " << pila01.size() << " cout << "El elemento que esta en el tope de la pila es:" <<i
elementos" << endl; <<endl;
cout << endl; cout << endl;
}
pila01.pop(); //liberamos el elemento que esta en el tope de
pila01.push(10); //insertar elementos en la pila la pila
int j= pila01.top(); i=pila01.size();
cout << "Elemento01: " << j << ' '; cout << "Despues de un pop, el tamano de la pila es:" <<i
cout << endl; <<endl;
cout << endl;
pila01.push(20);//insertar elementos en la pila
j=pila01.top(); i=pila01.top(); //obtenemos el elemento que esta en el tope
cout << "Elemento02: "<< j << ' '; de la pila
cout << endl; cout << "Despues de un pop, el primer elemento de la pila
es:" <<i <<endl;
pila01.push(30); //insertar elementos en la pila cout << endl;
j=pila01.top();
cout << "Elemento03: "<< j << ' '; system("pause"); //llamada para esperar a que se presione
cout << endl; una tecla para salir
return 0;
pila01.push(40); //insertar elementos en la pila }
j=pila01.top();
cout << "Elemento04: "<< j << ' ' <<endl;;
cout << endl;

CORRIDA DEL ALGORITMO Y EXPLICACION

Existen diversas estructuras de datos en la literatura para el uso en programas computacionales, a

continuación se describen algunas de ellas.

arreglos dinamicos(vectores)
colas(queue)
pilas(stack)
monticulos(priority_queue)
listas ligadas(list)
arboles(set)
arreglos asociativos(map)

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 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;
}

Cola de Prioridad
Una cola de prioridad (priority queue) es una estructura de datos muy similar a una lista pero
cada elemento tiene una prioridad asociada. En una cola de prioridad, el elemento con más alta
prioridad es manejado/procesado antes que un elemento de prioridad baja. Si existen dos
elementos con prioridades iguales, entonces se procesa de acuerdo al orden de la cola.
Una implementación usual es con un heap. (esto si quieren no lo mencionen dado que a nivel
conceptual son distintos!). Igualmente, la inserción dentro de una cola de forma ordenada, O(n), es
una opción válida para la explicación.

Ejemplo de implementación de primitivas de una cola de prioridad en c++

#include <iostream>
#include <stdlib.h>
using namespace std;

struct nodo
{
char dato;
int priori; // prioridad del nodo
struct nodo *sgte;
};

struct cola
{
nodo *delante;
nodo *atras ;
};

struct nodo *crearNodo( char x, int pr)

{
struct nodo *nuevoNodo = new(struct nodo);
nuevoNodo->dato = x;
nuevoNodo->priori = pr;
return nuevoNodo;
};

void encolar( struct cola &q, char valor, int priori )

{

struct nodo *aux = crearNodo(valor, priori);

aux->sgte = NULL;

if( q.delante == NULL)

q.delante = aux; // encola el primero elemento
else
(q.atras)->sgte = aux;

q.atras = aux; // puntero que siempre apunta al ultimo elemento

}

void muestraCola( struct cola q )

{
struct nodo *aux;

aux = q.delante;

cout << " Caracter Prioridad " << endl;

cout << " ------------------- " << endl;

while( aux != NULL )

{
cout<<" "<< aux->dato << " | " << aux->priori << endl;
aux = aux->sgte;
}
}

void ordenarPrioridad( struct cola &q )

{
struct nodo *aux1, *aux2;
int p_aux;
char c_aux;

aux1 = q.delante;

while( aux1->sgte != NULL)

{
aux2 = aux1->sgte;

while( aux2 != NULL)

{
if( aux1->priori > aux2->priori )
{
p_aux = aux1->priori;
c_aux = aux1->dato;

aux1->priori = aux2->priori;
aux1->dato = aux2->dato;
 aux2->priori = p_aux;
aux2->dato = c_aux;
}

aux2 = aux2->sgte;
}

aux1 = aux1->sgte;
}
}

void insertar( struct cola &q, char c, int pr )

{
/* Encolando caracteres */
encolar( q, c, pr );

/* Ordenando por prioridad */

ordenarPrioridad( q );
}

void menu()
{
cout<<"\n\t COLAS CON PRIORIDAD EN C++ \n\n";
cout<<" 1. ENCOLAR "<<endl;
cout<<" 2. MOSTRAR "<<endl;
cout<<" 3. SALIR "<<endl;

cout<<"\n INGRESE OPCION: ";

}

int main()
{
struct cola q;

q.delante = NULL;
q.atras = NULL;

char c ; // caracter a encolar

int pr; // prioridad del caracter
int op; // opcion del menu
int x ; // numero que devuelve la funcon pop

do
{
menu(); cin>> op;

switch(op)
{
case 1:

cout<< "\n Ingrese caracter: ";

cin>> c;

cout<< "\n Ingrese prioridad: ";

cin>> pr;

insertar( q, c, pr );

cout<<"\n\n\t\tCaracter '" << c << "' encolado...\n\n";

break;

case 2:

cout << "\n\n MOSTRANDO COLA DE PRIORIDAD\n\n";

if(q.delante!=NULL)
muestraCola( q );
else
cout<<"\n\n\tCola vacia...!"<<endl;
 break;

default:
cout<<"\n\tOpcion incorecta..!"<<endl;
system("pause");
exit(0);
}

cout<<endl<<endl;
system("pause"); system("cls");

}while(op!=3);

return 0;
}

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
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"; }

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);