Pilas:

Una pila es una estructura de datos a la cual se puede acceder solo por un extremo de la misma.
Las operaciones de inserción y extracción se realizan a través del tope, por lo cual no se puede
acceder a cualquier elemento de la pila. Se la suele llamar estructura L.I.F.O.como acrónimo de las
palabras inglesas "last in, first out" (último en entrar, primero en salir). La pila se considera un
grupo ordenado de elementos, teniendo en cuenta que el orden de los mismos depende del
tiempo que lleven "dentro" de la estructura.

Colas:
Una cola es una colección de elementos homogéneos (almacenados en dicha estructura), en la
misma se pueden insertar elementos por uno de los extremos, llamado frente, y retirar los mismos
por el otro extremo, denominado final.
Es importante aclarar que, tanto el frente como el final de la cola, son los únicos indicados para
retirar e insertar elementos, respectivamente. Esto nos indica que no podemos acceder
directamente a cualquier elemento de la cola, sino solo al primero, o sea el que está o se
encuentra en el frente, y no se pueden insertar elementos en cualquier posición sino solo por el
final, así el elemento insertado queda como último.
Por esta razón la cola es denominada una estructura F.I.F.O., o simplemente una lista F.I.F.O., esto
representa el acrónimo de las palabras inglesas “first in, first out” (primero en entrar, primero en
salir). Gráficamente podemos representarla como:
Una lista doblemente enlazada es una lista lineal en la que cada nodo tiene dos
enlaces, uno al nodo siguiente, y otro al anterior.
Las listas doblemente enlazadas no necesitan un nodo especial para acceder a ellas,
pueden recorrerse en ambos sentidos a partir de cualquier nodo, esto es porque a
partir de cualquier nodo, siempre es posible alcanzar cualquier nodo de la lista, hasta
que se llega a uno de los extremos.
El nodo típico es el mismo que para construir las listas que hemos visto, salvo que
tienen otro puntero al nodo anterior:
struct nodo {
int dato;
struct nodo *siguiente;
struct nodo *anterior;
};
Árboles binarios. Conceptos • Definición: es un conjunto finito de elementos que está vacío o está
partido en tres subconjuntos disjuntos. – El primer subconjunto contiene un único elemento
llamado la raíz del árbol binario. – Los otros dos subconjuntos son a su vez árboles binarios,
llamados subárboles izquierdo y derecho. • El subárbol izquierdo o derecho puede estar vacío. •
Cada elemento de un árbol binario se denomina nodo

Crear pila
struct nodo {int dato;struct nodo *siguiente;};

2.2 Declaraciones de tipos paramanejar pilas en C:

Los tipos que definiremos normalmente para manejar pilas serán casi los mismosque para
manejar listas, tan sólo cambiaremos algunos nombres:

typedef struct _nodo {int dato;struct _nodo *siguiente;} tipoNodo;typedef tipoNodo

*pNodo;typedef tipoNodo *Pila;

insertar

void Push(Pila *pila, int v)

{pNodo nuevo;/* Crear un nodo nuevo */nuevo = (pNodo)malloc(sizeof(tipoNodo));nuevo->valor =

v;/* Añadimos la pila a continuación del nuevo nodo */nuevo->siguiente = *pila;/* Ahora, el
comienzo de nuestra pila es en nuevo nodo */*pila = nuevo

Lista

int insercion_en_lista_vacia (dl_Lista * lista, char *dato){

dl_Elemento *nuevo_elemento;
if ((nuevo_elemento = alloc (nuevo_elemento)) == NULL)
return -1;
strcpy (nuevo_elemento->dato, dato);
nuevo_elemento->anterior = lista->inicio;
nuevo_elemento->siguiente = lista->fin;
lista->inicio = nuevo_elemento;
lista->fin = nuevo_elemento;
lista->tamaño++;
return 0;
}
eliminar

void destruir(dl_Lista *lista){

while(lista->tamaño > 0)
sup(lista,1);
}

árbol binario

#include <iostream>
#include <cstdlib> void preOrden(ABB arbol)
using namespace std; {
if(arbol!=NULL)
struct nodo{ {
int nro; cout << arbol->nro <<" ";
struct nodo *izq, *der; preOrden(arbol->izq);
}; preOrden(arbol->der);
}
typedef struct nodo *ABB; }
/* es un puntero de tipo nodo que hemos
llamado ABB, que ulitizaremos void enOrden(ABB arbol)
para mayor facilidad de creacion de {
variables */ if(arbol!=NULL)
{
ABB crearNodo(int x) enOrden(arbol->izq);
{ cout << arbol->nro << " ";
ABB nuevoNodo = new(struct nodo); enOrden(arbol->der);
nuevoNodo->nro = x; }
nuevoNodo->izq = NULL; }
nuevoNodo->der = NULL;
void postOrden(ABB arbol)
return nuevoNodo; {
} if(arbol!=NULL)
void insertar(ABB &arbol, int x) {
{ postOrden(arbol->izq);
if(arbol==NULL) postOrden(arbol->der);
{ cout << arbol->nro << " ";
arbol = crearNodo(x); }
} }
else if(x < arbol->nro)
insertar(arbol->izq, x); void verArbol(ABB arbol, int n)
else if(x > arbol->nro) {
insertar(arbol->der, x); if(arbol==NULL)
} return;
 verArbol(arbol->der, n+1); for(int i=0; i<n; i++)
{
for(int i=0; i<n; i++) cout << " Numero del nodo " << i+1 << ":
cout<<" "; ";
cin >> x;
cout<< arbol->nro <<endl; insertar( arbol, x);
}
verArbol(arbol->izq, n+1);
} cout << "\n Mostrando ABB \n\n";
verArbol( arbol, 0);
int main()
{ cout << "\n Recorridos del ABB";
ABB arbol = NULL; // creado Arbol
cout << "\n\n En orden : ";
int n; // numero de nodos del arbol enOrden(arbol);
int x; // elemento a insertar en cada nodo cout << "\n\n Pre Orden : ";
preOrden(arbol);
cout << "\n\t\t ..[ ARBOL BINARIO DE cout << "\n\n Post Orden : ";
BUSQUEDA ].. \n\n"; postOrden(arbol);

cout << " Numero de nodos del arbol: "; cout << endl << endl;
cin >> n;
cout << endl; system("pause");
return 0;
}