VIDEO PILAS

EJERCICIO EN CLASE

#include <iostream.h>
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
// Estructura
struct nodoCola
{
    int dato;
  nodoCola *sig;
};struct nodoCola *ult;
//Menu
int menu()
{
    int op;
  clrscr();
    cout<<"\n\t\tMENU PRINCIPAL";
    cout<<"\n\n1.Inicializar cola";
    cout<<"\n2. Encolar";
    cout<<"\n3. Desencolar";
    cout<<"\n4. Recorrer";
    cout<<"\n5. Invertir Contenidos";
    cout<<"\n6. Verificar Estado de la Cola";
    cout<<"\n7. Detruir Cola";
    cout<<"\n8. Salir";
    cout<<"\n\n\t\t--> Elija Opcion:  ";
    cin>>op;
    return op;
}
//Definicion de funciones
 void inicializar(struct nodoCola **, struct nodoCola **);
 void desencolar(struct nodoCola **,struct nodoCola **);
 void recorrer(struct nodoCola **, struct nodoCola **,int x);
 void encolar(struct nodoCola **, struct nodoCola **);
 void verificar(struct nodoCola**,struct nodoCola **);
 void destruir(struct nodoCola**,struct nodoCola **);
 //Funcion inicializar
 void inicializar(struct nodoCola **prim,struct nodoCola **ult)
 { clrscr();
  *prim=NULL;
  cout<<"\nCola Inicializada.";
  getch();
 }
//Funcion Encolar
 void encolar(struct nodoCola **prim, struct nodoCola **ult,int dat)
 {
  struct nodoCola *aux;
  aux=new nodoCola;
  if(aux==NULL)
   {
    cout<<"\nMemoria Insuficiente. ";
    getch();
   }
  aux->dato=dat;
  aux->sig=NULL;
  if(*prim==NULL)
  { *prim=aux;
  *ult=aux;
 }
  else
  { (*ult)->sig=aux;
  *ult= aux;
  }
  getch();
 }
//Funcion Desencolar
 void desencolar(struct nodoCola **prim, struct nodoCola **ult)
 { clrscr();
  struct nodoCola  *aux;
  if(*prim==NULL)
    cout<<"COLA Vacia";
  else
   {
    aux=*prim;
    cout<<"Elemento eliminado: "<<(*prim)->dato;
    *prim=aux->sig;
    delete aux;
   }
 getch();
 }
 //Funcion recorrer
 void recorrer(struct nodoCola **prim, struct nodoCola **ult,int dato)
 {clrscr();
  struct nodoCola  *aux;
  if(*prim==NULL)
    cout<<"\nCOLA Vacia. ";
  else
  {
    aux=*prim;
    while(aux!=NULL)
    {
    cout<<"Elemento: "<<aux->dato<<"\n";
    aux=aux->sig;
    }
  }
  getch();
}
// Inverttir Contenidos


void invertir(struct nodoCola **prim, struct nodoCola **ult)
{
   int dat;
    if(*prim==NULL)
    cout<<"COLA Vacia";
    else
    {
      cout<<"\n\n\nPrimer dato ingresado : "<<(*prim)->dato<<"\t";
      cout<<"Ultimo dato ingresado: "<<(*ult)->dato<<"\n";
     dat=(*ult)->dato;
     (*ult)->dato=(*prim)->dato;
      (*prim)->dato=dat;
      cout<<"\n\n\n\t\t ***LOS DATOS INVERTIDOS SON***:    ";
      cout<<"\n\nPrimer dato ingresado: "<<(*prim)->dato<<"\t";
      cout<<"\tUltimo dato ingresado: "<<(*ult)->dato<<"\n";
    }
    getch();
}


//Funcion Verificar stado de la Cola
void verificar(struct nodoCola **prim,struct nodoCola **ult)
 { clrscr();
  struct nodoCola  *aux;
  if(*prim==NULL)
    cout<<"\n\tCola Vacia";
  else
   { cout<<"\n\tLa Cola Contiene Elementos ";
    }
 getch();
 }

//Funcion Destruir toda la Cola

void destruir(struct nodoCola **prim, struct nodoCola **ult)
 {
     struct nodoCola  *aux;
     if(*ult==NULL)
     cout<<"\n\tCola Vacia. ";
     else
     do
     { aux=*prim;
       *prim=(*prim)->sig;
       delete aux;
     }
     while (*prim!=NULL);
  cout<<"\n\tLa Cola esta Destruida";
  getch();
 }




// principal
 int main()
 {
   struct nodoCola  *prim,*ult;
  int dat,opc;
    do
     { opc=menu();
    switch(opc)
    {
    case 1:{inicializar(&prim, &ult);break;}
    case 2:{ cout<<"\nEntre el dato: ";
        cin>>dat;
        encolar(&prim, &ult,dat);
        break;
      }
    case 3:{desencolar(&prim, &ult);break;}
    case 4: {recorrer(&prim, &ult,dat);break;}
            case 5:{invertir(&prim, &ult);break;}
            case 6:{verificar(&prim, &ult);break;}
            case 7:{destruir(&prim, &ult);break;}
     }
    }
    while(opc!=8);
    return 0;
}

TDA COLA

Una COLA es una estructuras de datos  caracterizada por ser una secuencia de

 elementos en la que la operación de inserción se realiza por un extremo y la operación

 de extracción por el otro. También se le llama estructura FIFO ( primer elemento en

entrar será también el primero en salir).

 OPERACIONES BASICAS 

*Crear: se crea la cola vacía. 
*Encolar (añadir elemento): se añade un elemento a la cola.

Dejando claro que seañade al final.

*Desencolar (Eliminar elemento): se elimina el primer elemento que entro en la cola. 
*Frente (consultar): se devuelve el primer elemento que entro en la cola.

INICIALIZADORAS

Nombre: Inicializar.
Funcion: Inicializar la estructura.
pre: nada
post: c= { }.

CREADORAS

Nombre: Encolar
Funcion: Insertar un elemento en la cola.
pre: C={ },e
        C={e1,e2,e3...en}e
post: C= {e}
         C={e1,e2,e3...en+1}
 
Nombre: Desencolar
Funcion: Elimina elementos de la cola.
pre: C= { }
       C= {e1,e2,e3......e n}

post: Cola vacia.
        C= {e1,e2,e3......e n -1}

ANALIZADORAS

Nombre: Consultar
Funcion: Retorna el primer elemento.
pre: C= { }
       C= {e1,e2,e3.....e n}

post: Cola vacia.
        C= e1.

Nombre: Recorrer cola
Funcion: Devuelve los elementos de la cola.
pre: C= { }, e
      C= {e1,e2,e3.....e n},e

post: Cola vacia
        Elemento encontrado.
       C={e1,e2,e3...en}
 

SEUDOCODIGO

#include <iostream.h>
#include <stdlib.h>
#include <conio.h>
#include <stdio.h>
// Estructura
struct nodoCola
{
    int dato;
  nodoCola *sig;
};struct nodoCola *ult;
//Menu
int menu()
{
    int op;
  clrscr();
    cout<<"\n\t\tMENU PRINCIPAL";
    cout<<"\n\n1.Inicializar cola";
    cout<<"\n2. Encolar";
    cout<<"\n3. Desencolar";
    cout<<"\n4. Recorrer";
    cout<<"\n5. Salir";
    cout<<"\n\n\t\t--> Elija Opcion:  ";
    cin>>op;
    return op;
}
//Definicion de funciones
 void inicializar(struct nodoCola **, struct nodoCola **);
 void desencolar(struct nodoCola **,struct nodoCola **);
 void recorrer(struct nodoCola **, struct nodoCola **,int x);
 void encolar(struct nodoCola **, struct nodoCola **);

 //Funcion inicializar
 void inicializar(struct nodoCola **prim,struct nodoCola **ult)
 { clrscr();
  *prim=NULL;
  cout<<"\nCola Inicializada.";
  getch();
 }
//Funcion Encolar
 void encolar(struct nodoCola **prim, struct nodoCola **ult,int dat)
 {
  struct nodoCola *aux;
  aux=new nodoCola;
  if(aux==NULL)
   {
    cout<<"\nMemoria Insuficiente. ";
    getch();
   }
  aux->dato=dat;
  aux->sig=NULL;
  if(*prim==NULL)
  { *prim=aux;
  *ult=aux;
 }
  else
  { (*ult)->sig=aux;
  *ult= aux;
  }
  getch();
 }
//Funcion Desencolar
 void desencolar(struct nodoCola **prim, struct nodoCola **ult)
 { clrscr();
  struct nodoCola  *aux;
  if(*prim==NULL)
    cout<<"COLA Vacia";
  else
   {
    aux=*prim;
    cout<<"Elemento eliminado: "<<(*prim)->dato;
    *prim=aux->sig;
    delete aux;
   }
 getch();
 }
 //Funcion recorrer
 void recorrer(struct nodoCola **prim, struct nodoCola **ult,int dato)
 {clrscr();
  struct nodoCola  *aux;
  if(*prim==NULL)
    cout<<"\nCOLA Vacia. ";
  else
  {
    aux=*prim;
    while(aux!=NULL)
    {
    cout<<"Elemento: "<<aux->dato<<"\n";
    aux=aux->sig;
    }
  }
  getch();
}




// principal
 int main()
 {
   struct nodoCola  *prim,*ult;
  int dat,opc;
    do
     { opc=menu();
    switch(opc)
    {
     case 1:{inicializar(&prim, &ult);break;}
     case 2:{ cout<<"\nEntre el dato: ";
             cin>>dat;
             encolar(&prim, &ult,dat);
             break;
            }
     case 3:{desencolar(&prim, &ult);break;}
     case 4: {recorrer(&prim, &ult,dat);break;}

     }
    }
    while(opc!=5);
    return 0;
}

QUIZ

*Nombre: Primer elemento
 Funcion: Muestra el primer elemento de la pila
 Pre: p={ }
        p={e1,e2,e3...en}

 Post: "Pila vacia"
          p={e1}

*Nombre: Ordenar elemento
 Funcion: Ordena los elementos de la pila 

 Pre: p={ }
        p={e1,e2,e3...en}

 Post: "Pila vacia"
          p={e1>e2>e3....>en}

#include<stdio.h>
#include<conio.h>
#include<iostream.h>


struct nodoPila


{   int dato;
     nodoPila *sig;
};
struct nueva
{
    int dato;
    struct nueva *sig;
};struct nueva *primero,*ultimo;


int menu()

{   int opc;
     clrscr();
     cout<<"       MENU PRINCIPAL";
     cout<<"\n1. Inicializar Pila";
     cout<<"\n2. Apilar (push)";
     cout<<"\n3. Recorrer Pila";
     cout<<"\n4. Desapilar (pop)";
     cout<<"\n5. Contar elementos";
     cout<<"\n6. Numero mayor";
     cout<<"\n7. Primer elemento";
     cout<<"\n8. Mostrar ordenada";
     cout<<"\n9. Salir";
     cout<<"\n\n\nOpcion: ";
     cin>>opc;
     return opc;

}



void inicializar(struct nodoPila **);

void desapilar(struct nodoPila **);
void recorrer(struct nodoPila **);
void apilar(struct nodoPila **, int x);
void recorrer(struct nodoPila **tope)


{  struct nodoPila *aux;
      if(*tope==NULL)
             cout<<"\nPila Vacia. ";
      else
         {  aux=*tope;
             while(aux!=NULL)
             {  cout<<"Elemento: "<<aux->dato<<"\n";
                     aux=aux->sig;
             }

         }
      getch();

}


 //Funcion inicializar la pila


void inicializar(struct nodoPila **tope)


 {   *tope=NULL;
      cout<<"\nPila Inicializada.";
      getch();
}


//Funcion apilar


void apilar(struct nodoPila **tope, int dat)

{    struct nodoPila *aux;
      aux=new nodoPila;
      if(aux==NULL)
      {   cout<<"\nMemoria Insuficiente. ";
            getch();
      }

      aux->dato=dat;
      aux->sig=*tope;
      *tope=aux;
}


//Funcion desapilar


void desapilar(struct nodoPila **tope)
{   struct nodoPila *aux;
      if(*tope==NULL)
             cout<<"Pila Vacia";
      else
            {   aux=*tope;
                 cout<<"Elemento eliminado: "<<(*tope)->dato;
                 *tope=(*tope)->sig;
                  delete aux;
            }
      getch();

}


//Funcion Contar


void contar(struct nodoPila **tope)
 { clrscr();
     struct nodoPila *aux;
     int z=0;
     if(*tope==NULL)
             cout<<"Pila Vacia";
     else
            { aux=*tope;
                while(aux!=NULL)
             {   z++;
                     aux=aux->sig;
             }
                cout<<"\nEl numero de elementos encontrados es : "<<z<<"\n";
      }
     getch();
 }


//Funcion del mumero mayor

void nummayor(struct nodoPila **tope)
 {  clrscr();
     struct nodoPila *aux;
     int nmy=0;
     if(*tope==NULL)
          cout<<"Pila vacia";
     else
          {  aux=*tope;
              while(aux!=NULL)
          {  if(nmy<aux->dato)
                     nmy=aux->dato;
                aux=aux->sig;
          }
        cout<<"El numero mayor es: "<<nmy;
     }
    getch();
}


//Funcion Primer elemento


void primerelemento(struct nodoPila **tope )
 { clrscr();
     struct nodoPila *aux;
     int dat=0;
     aux=*tope;
     if(aux==NULL)
             cout<<"Pila Vacia";
     else{
        while(aux!=NULL){
            dat=aux->dato;
            aux=aux->sig;
        }
        cout<<"\nEl primer elememto es  "<<dat;
     }
     getch();
 }




 //Funcion ordenar  Elementos


void ordenar(struct nodoPila **tope)
 {  struct nodoPila *auxi;
    struct nueva *nue,*aux,*ant;
    if(*tope==NULL)
        cout<<"Pila vacia";
    else{
        auxi=*tope;
        while(auxi!=NULL){
            if(primero==NULL){
                primero=new nueva;
                primero->dato=auxi->dato;
                primero->sig=NULL;
                ultimo=primero;
            }
            else
            {   nue=new nueva;
                nue->dato=auxi->dato;
                aux=primero;
                while(aux!=NULL&&aux->dato<nue->dato){
                    ant=aux;
                    aux=aux->sig;
                }
                if(aux==primero){
                    nue->sig=primero;
                    primero=nue;
                }else{
                    if(aux==NULL){
                        ultimo->sig=nue;
                        nue->sig=NULL;
                        ultimo=nue;
                    }else
                        nue->sig=aux;
                        ant->sig=nue;
                }
            }
            auxi=auxi->sig;
        }
        aux=primero;
        while(aux!=NULL){
            cout<<aux->dato<<"\t";
            aux=aux->sig;
        }
        getch();
    }
}

int main()


{   struct nodoPila *tope;
      int dat,opc;
     do
     {   opc=menu();
          switch(opc)
          {
                case 1:{inicializar(&tope);break;}
                case 2:{  cout<<"\nEntre el dato: ";
                                cin>>dat;
                                apilar(&tope,dat);
                                 break;
                              }
                case 3:{recorrer(&tope);break;}
                case 4:{desapilar(&tope);break;}
                case 5:{contar(&tope);break;}
                case 6:{nummayor(&tope);break;}
                case 7:{primerelemento(&tope);break;}
                case 8:{cout<<" La lista en Orden es\n\n";ordenar(&tope);break;}

             }

      }while(opc!=9);
     return 0;

}

EJERCICOS

 Ejercicio con dos nuevas analizadoras

*Nombre: Contar

 Funcion: Contar elementos

 Pre: p={ }

        p={e1,e2,e3...en}

 Post: "Pila vacia"

          p={e1,e2,e3,en++}

*Nombre: Numero mayor

 Funcion: Encontrar el numero mayor entre los elementos de una pila

 Pre: p={ }

        p={e1,e2,e3...en}

Post: "Pila vacia"

       p={e1>e2>e3>en}

//Programa....

#include<stdio.h>

#include<conio.h>
#include<iostream.h>

struct nodoPila

{   int dato;

    nodoPila *sig;

};

int menu()

{

    int opc;
    clrscr();
    cout<<"       MENU PRINCIPAL";
    cout<<"\n1. Inicializar Pila";
    cout<<"\n2. Apilar (push)";
    cout<<"\n3. Recorrer Pila";
    cout<<"\n4. Desapilar (pop)";
    cout<<"\n5. Contar elementos";
    cout<<"\n6. Numero mayor";
    cout<<"\n7. Salir";
    cout<<"\n\n\nOpcion: ";
    cin>>opc;
    return opc;

}


void inicializar(struct nodoPila **);

void desapilar(struct nodoPila **);
void recorrer(struct nodoPila **);
void apilar(struct nodoPila **, int x);
void recorrer(struct nodoPila **tope)

{

     struct nodoPila *aux;
     if(*tope==NULL)
          cout<<"\nPila Vacia. ";
     else
       {  aux=*tope;
          while(aux!=NULL)
          {  cout<<"Elemento: "<<aux->dato<<"\n";
                aux=aux->sig;
          }

       }
     getch();

}

 //Funcion inicializar la pila

void inicializar(struct nodoPila **tope)

 {   *tope=NULL;
     cout<<"\nPila Inicializada.";
     getch();

 }

//Funcion apilar

void apilar(struct nodoPila **tope, int dat)
 

{    struct nodoPila *aux;
     aux=new nodoPila;
     if(aux==NULL)
     {   cout<<"\nMemoria Insuficiente. ";
         getch();
     }

     aux->dato=dat;
     aux->sig=*tope;
     *tope=aux;
}

//Funcion desapilar

void desapilar(struct nodoPila **tope)
{   struct nodoPila *aux;
     if(*tope==NULL)
          cout<<"Pila Vacia";
     else
         {   aux=*tope;
             cout<<"Elemento eliminado: "<<(*tope)->dato;
             *tope=(*tope)->sig;
              delete aux;
         }
     getch();

}

//Funcion Contar

void contar(struct nodoPila **tope)
 { clrscr();
    struct nodoPila *aux;
    int z=0;
    if(*tope==NULL)
          cout<<"Pila Vacia";
    else
         { aux=*tope;
            while(aux!=NULL)
          {   z++;
                aux=aux->sig;
          }
            cout<<"\nEl numero de elementos encontrados es : "<<z<<"\n";
     }
    getch();
 }

//Funcion del mumero mayor


void nummayor(struct nodoPila **tope)
 {  clrscr();
    struct nodoPila *aux;
    int nmy=0;
    if(*tope==NULL)
        cout<<"Pila vacia";
    else
        {  aux=*tope;
           while(aux!=NULL)
        {  if(nmy<aux->dato)
                nmy=aux->dato;
            aux=aux->sig;
        }
      cout<<"El numero mayor es: "<<nmy;
    }
   getch();
}

int main()

{   struct nodoPila *tope;
     int dat,opc;
     do
     {   opc=menu();
          switch(opc)
          {
                case 1:{inicializar(&tope);break;}
                case 2:{  cout<<"\nEntre el dato: ";
                                cin>>dat;
                                apilar(&tope,dat);
                                 break;
                              }
                case 3:{recorrer(&tope);break;}
                case 4:{desapilar(&tope);break;}
                case 5:{contar(&tope);break;}
                case 6:{nummayor(&tope);break;}
          }

     }while(opc!=7);
     return 0;

}

TDA PILA

Una pila es una estructuras de datos (estructura dinamica) en la que el modo de acceso a sus elementos
es de tipo  LIFO (último en entrar, primero en salir) que permite
almacenar y recuperar datos, En una

 pila, cada elemento apunta al siguiente excepto el último

 que no tiene sucesor y el valor es null.

.

Para el manejo de los datos se cuenta con operaciones básicas
y otras complementaria, dentro de las basicas esta:
  inicializar : inicia la pila
apilar (push) : añade  un objeto en la pila
desapilar( pop): retira el último elemento apilado.
 Las complemetarias talescomo son las:
analizadoras

 

INICIALIZADORAS

Nombre: Inicializar

Función: Inicializa la estructura

 Pre: - ( pila vacía)

  Post: p={}

CREADORAS

              APILAR

Utilidad: Inserta  elementos en la pila.

 Pre: p={},e

         p={e1,e2,…en}

 

 Post: p={e}

          p={e1,e2,…en}

DESAPILAR

Función : Elimina un elemento de la pila

 Pre: p={}

        p={e1,e2,e3,...en}

 Post: “No hay elemento para     eliminar”

       p={e1,e2,e3,...en-1}

ANALIZADORAS

                 RECUPERAR DATO

                 

Función: Retorna el valor guardado en el Tope

 Pre: p={}

        p={e1,e2,e3,...en}

 Post: “No hay elementos en la Pila”

                       Tope=en

          BUSCAR ELEMENTOS

           

Función: Busca  los elementos de una pila

Pre: p={}       

 p={e1,e2,e3,...en} e.

Post: “Pila vacia”

 Elemento encontrado

 

Programa PILA

#include<stdio.h>

#include<conio.h>

#include<iostream.h>

char letra;

struct nodoPila

{

  int dato;

  nodoPila *sig;

};

int menu()

{

    int opc;

   clrscr();

   cout<<"       MENU PRINCIPAL";

   cout<<"\n1. Inicializar Pila";

   cout<<"\n2. Apilar (push)";

   cout<<"\n3. Recorrer Pila";

   cout<<"\n4. Desapilar (pop)";

   cout<<"\n5. Salir";

   cout<<"\nOpcion: ";

   cin>>opc;

   return opc;

}

void inicializar(struct nodoPila **);

void desapilar(struct nodoPila **);

void recorrer(struct nodoPila **);

void apilar(struct nodoPila **, int x);

void recorrer(struct nodoPila **tope)

{

   struct nodoPila *aux;

   if(*tope==NULL)

   cout<<"\nPila Vacia. ";

   else

    {

      aux=*tope;

     while(aux!=NULL)

      {

         cout<<"Elemento: "<<aux->dato<<"\n";

         aux=aux->sig;

      }

 }

cin>>letra;

}

//Funcion inicializar

void inicializar(struct nodoPila **tope)

{

   *tope=NULL;

     cout<<"\nPila Inicializada.";

     cin>>letra;

}

//Funcion apilar

void apilar(struct nodoPila **tope, int dat)

{

struct nodoPila *aux;

aux=new nodoPila;

if(aux==NULL)

{

 cout<<"\nMemoria Insuficiente. ";

 cin>>letra;

}

aux->dato=dat;

aux->sig=*tope;

*tope=aux;

}

//Funcion desapilar

void desapilar(struct nodoPila **tope)

{

struct nodoPila *aux;

if(*tope==NULL)

 cout<<"Pila Vacia";

else

{

 aux=*tope;

 cout<<"Elemento eliminado: "<<(*tope)->dato;

 *tope=(*tope)->sig;

 delete aux;

}

cin>>letra;

}

//Cuerpo principal

int main()

{

struct nodoPila *tope;

int dat,opc;

do

{

opc=menu();

switch(opc)

 {

     case 1:{inicializar(&tope);break;}

     case 2:{  cout<<"\nEntre el dato: ";

                    cin>>dat; 

                   apilar(&tope,dat); 

                   break; 

               } 

     case 3:{recorrer(&tope);break;} 

     case 4:{desapilar(&tope);break;}

                }

 }

while(opc!=5);

return 0;

}