ALGORITMOS Y ESTRUCTURAS DE DATOS hoja 1/3

Nota: En pilas solo utilizar push y pop, usar pilas auxiliares en caso de necesitarlo

El nodo con dato simple

struct tr {
int a;
int b;
}

Struct Nodo{ Struct Nodo{

int info; tr info;
Nodo* sgte; Nodo* sgte;
} }

Nodo* Pila = NULL; Nodo* Pila = NULL;

Cargar en pila con dato simple Cargar en pila con struct
void Push (Nodo*& Pila, int x){ void Push (Nodo*& Pila, tr x){
Nodo* p = new Nodo(); //pedir memoria Nodo* p = new Nodo();
p->info = x;//cargar la información p->info = x;
p->sgte = Pila;//enlace nuevo con pila p->sgte = Pila;
Pila = p; //actualizar el puro al inicio pila = p:
return; return;
} }

Invocación Invocación
int x = 10; tr x;
x.a = 10;
x.b = 15;
Push(Pila, x); Push (Pila, x);
Sacar de pila con dato simple Sacar de pila con struct
int Pop (Nodo* & Pila){ tr Pop (Nodo* & Pila){
int x; tr x;
Nodo* p = Pila; Nodo* p = Pila;
x = p->info; x = p->info;
Pila = p->sgte; Pila = p->sgte;
delete p; delete p;
return x; return x;
} }

int x; fr x;
while (Pila!=NULL){ while (Pila!=NULL){
x = pop(Pila); x = pop(Pila);
cout << x <<endl; cout << x.a <<x.b <<endl;
} }
Con utilización de plantillas
Nodo
template <typename T> struct Nodo
{
T info; // valor que contiene el nodo
Nodo<T>* sig; // puntero al siguiente nodo
};

push
template <typename T> void push(Nodo<T>*& Pila, T x)
{
Nodo<T>* p = new Nodo<T>();
p ->info = x;
p->sgte = Pila;
Pila = p;
return;
}

pop
 ALGORITMOS Y ESTRUCTURAS DE DATOS hoja 2/3

template <typename T> T pop(Nodo<T>*&)

{
T x;
Nodo<T>* p = Pila;
x = p ->info;
Pila = p->sgte;
delete p;
return x;
}

Invocacion
Nodo<int>* pila = NULL;

push<int>(pila,10);
push<int>(pila,20);
push<int>(pila,30);

while( pila!=NULL )cout << pop<int>(pila) << endl;

Ejercicio Nro. 01:

Dada una pila y un valor I, desarrollar un procedimiento que elimine los 2 primeros nodos de la pila y deje el valor I como
primero. (Definir parámetros y codificar).

Ejercicio Nro. 02:

Dada una pila y un valor I, desarrollar un procedimiento que inserte I como tercer valor de la pila. (Definir parámetros y
codificar).

Ejercicio Nro. 03:

Idem ejercicio 01 pero retornando un parámetro con valor 'S' o 'N' según haya sido exitoso o no el requerimiento. (Definir
parámetros y codificar).

Ejercicio Nro. 04:

Dada una pila y dos valores X e I, desarrollar un procedimiento que inserte el valor X en la posición I de la pila si es
posible. (Definir parámetros y codificar).

Ejercicio Nro. 05:

Dada una pila y un valor X, desarrollar un procedimiento que inserte el valor X en la última posición de la pila y la retorne.
(Definir parámetros y codificar).

Ejercicio Nro. 06:

Dada una pila y dos valores X e Y, desarrollar un procedimiento que reemplace cada valor igual a X que se encuentre en la
pila por el valor Y retornando la pila modificada. En caso de no haber ningún valor igual a X retornar la pila sin cambio.
(Definir parámetros y codificar).

Ejercicio Nro. 07:

Definir una función INVERSA que evalúe dos conjuntos de caracteres separados por un punto y retorne True si los
conjuntos son inversos (ej: ABcDe.eDcBA) o False si no lo son. Los conjuntos deben ingresarse por teclado. (Definir
parámetros y codificar).

Ejercicio Nro. 08:

Desarrollar un procedimiento que ingrese por teclado un conjunto de Apellidos y Nombre de alumnos y los imprima en
orden inverso al de ingreso. (Definir parámetros y codificar).

Ejercicio Nro. 09:

 ALGORITMOS Y ESTRUCTURAS DE DATOS hoja 3/3

Dada una pila desarrollar un procedimiento que ordene la misma de acuerdo al valor de sus nodos y la retorne. Solo se
deben usar pilas. (Definir parámetros y codificar).