COLA Y PILA

                          EJERCICIOS DE PILA Y COLA                   

COLA:                                                                                                                

#include <iostream.h>

#include <conio.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

struct datos {

 int dato;

 datos *s;

 }*p,*aux,*u;

void insertar (int dat);

void borrar ();

void listar ();

main()

{

int opc,y;

do

{

cout<<"\n1. Insertar";

cout<<"\t2. Borrar";

cout<<"\t3. Listar";

cout<<"\t4. Salir";

cout<<"\n Ingrese opcion: ";cin>>opc;

switch(opc)

{

case 1: cout<<"Ingrese dato: ";

 cin>>y;

 insertar(y);

 cout<<"\nDato insertado!!";

 break;

case 2: borrar();

 break;

case 3: listar(); break;

case 4: exit(1);

default: cout<<"\n Opcion no valida!!"; break;

}

}while(opc);

}

void insertar (int dat)

{

aux=new(datos);

aux->dato=dat;

if(u)

{

u->s=aux;

aux->s=NULL;

u=aux;

}

else

{

p=u=aux;

}

}

void borrar()

{

if(p)

{

aux=p;

cout<<"\nElimino a " <<p->dato;

p=aux->s;

delete(aux);

}

else

{

cout<<"\n No hay datos";

}

}

void listar()

{

int i;

if(!u)

{

cout<<"\n No hay datos en la cola";

return;

}

aux=p;

while(aux)

{

cout<<"\n"<<++i<<" - "<<aux->dato;

aux=aux->s;

}

}

                               

____________________________________________________________

PILA:                                                                                                            

#include <iostream.h>

#include <conio.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

struct pilas

{

int d;

pilas *a;

}*c,*e;

void menu(void);

void ingresar(void);

void sacar (void);

void actualizar_pila(void);

main()

{

menu();

}

void menu(void)

{

int y,opc;

 for(;;)

 {

 cout<<"\n1. Ingresar datos";

 cout<<"\t2. Sacar datos";

 cout<<"\t0. Terminar";

 cout<<"\n Ingrese opcion: ";cin>>opc;

 switch(opc)

 {

 case 1:

 ingresar();

 break;

 case 2: sacar();

 break;

 case 0: exit(1);

 default: cout<<"\n Opcion no valida!!"; break;

 }

actualizar_pila();

cout<<"\n\nOprima una tecla para continuar";

getch();

 }

}

void ingresar (void)

{

 if(!c)

 {

 c=new(pilas);

 cout<<"Ingrese elemento: ";

 cin>>c->d;

 c->a=NULL;

 return;

 }

 e=new(pilas);

 cout<<"\nIngrese elemento: ";

 cin>>e->d;

 e->a=c;

 c=e;

}

void sacar(void)

{

 if(!c)

 {

 cout<<"\n\nNo hay elementos!!";

 return;

 }

 e=new(pilas);

 e=c;

 cout<<"\n\nElemento eliminado: " <<e->d;

 c=e->a;

 delete(e);

}

void actualizar_pila(void)

{

 int y=2,i,ca=0;

 e=c;

 while(e)

 {

 ca++;

 e=e->a;

 }

for(i=0;i<=ca;i++)

 {

 cout<<" ";

 }

 //muestra lo que tiene la pila!!

 i=0;

 e=c;

 while(e)

 {

 cout<<"\n";

 cout<<++i<<" - "<<e->d;

 e=e->a;

 }

}

CORPORACIÓN IBEROAMERICANA DE ESTUDIOS

MATERIA:
ESTRUCTURA DE DATOS


INTEGRANTES DEL TRABAJO:

• LICETH REPIZO PRADA
• NILSON HUERFANO
• FABIAN IBAÑEZ

MAESTRO:

• JORGE RODRIGUEZ

JORNADA:
SÁBADOS 8AM-12PM

LISTAS EN C++

listas en c++

__________________________________________________________________

EJEMPLOS DE LISTAS                                                                                           

LISTAS :

#include <iostream>

using namespace std;

class nodo {

   public:

    nodo(int v, nodo *sig = NULL)

    {

       valor = v;

       siguiente = sig;

    }

   private:

    int valor;

    nodo *siguiente;

       

   friend class lista;

};

typedef nodo *pnodo;

class lista {

   public:

    lista() { primero = actual = NULL; }

    ~lista();

   

    void Insertar(int v);

    void Borrar(int v);

    bool ListaVacia() { return primero == NULL; }

    void Mostrar();

    void Siguiente();

    void Primero();

    void Ultimo();

    bool Actual() { return actual != NULL; }

    int ValorActual() { return actual->valor; }

   

   private:

    pnodo primero;

    pnodo actual;

};

lista::~lista()

{

   pnodo aux;

  

   while(primero) {

      aux = primero;

      primero = primero->siguiente;

      delete aux;

   }

   actual = NULL;

}

void lista::Insertar(int v)

{

   pnodo anterior;

   // Si la lista está vacía

   if(ListaVacia() || primero->valor > v) {

      // Asignamos a lista un nievo nodo de valor v y

      // cuyo siguiente elemento es la lista actual                   

      primero = new nodo(v, primero);

   }

   else {

      // Buscar el nodo de valor menor a v

      anterior = primero;

      // Avanzamos hasta el último elemento o hasta que el siguiente tenga

      // un valor mayor que v

      while(anterior->siguiente && anterior->siguiente->valor <= v)

         anterior = anterior->siguiente;

      // Creamos un nuevo nodo después del nodo anterior, y cuyo siguiente

      // es el siguiente del anterior

      anterior->siguiente = new nodo(v, anterior->siguiente);

   }

}

void lista::Borrar(int v)

{

   pnodo anterior, nodo;

  

   nodo = primero;

   anterior = NULL;

   while(nodo && nodo->valor < v) {

      anterior = nodo;

      nodo = nodo->siguiente;

   }

   if(!nodo || nodo->valor != v) return;

   else { // Borrar el nodo

      if(!anterior) // Primer elemento

         primero = nodo->siguiente;

      else  // un elemento cualquiera

         anterior->siguiente = nodo->siguiente;

      delete nodo;

   }  

}

void lista::Mostrar()

{

   nodo *aux;

  

   aux = primero;

   while(aux) {

      cout << aux->valor << "-> ";

      aux = aux->siguiente;

   }

   cout << endl;

}

void lista::Siguiente()

{

   if(actual) actual = actual->siguiente;

}

void lista::Primero()

{

   actual = primero;

}

void lista::Ultimo()

{

   actual = primero; 

   if(!ListaVacia())

      while(actual->siguiente) Siguiente();

}

int main()

{

   lista Lista;

  

   Lista.Insertar(500);

   Lista.Insertar(1000);

   Lista.Insertar(1500);

   Lista.Insertar(2000);

   Lista.Insertar(2500);

   Lista.Insertar(-500);

   Lista.Insertar(-1000);

   Lista.Insertar(-1500);

   Lista.Insertar(-2000);

   Lista.Insertar(-2500);

   Lista.Mostrar();

   cout << "Lista de elementos:" << endl;

   Lista.Primero();

   while(Lista.Actual()) {

      cout << Lista.ValorActual() << endl;

      Lista.Siguiente();

   }

   Lista.Primero();

   cout << "Primero: " << Lista.ValorActual() << endl;

  

   Lista.Ultimo();

   cout << "Ultimo: " << Lista.ValorActual() << endl;

  

   Lista.Borrar(500);

   Lista.Borrar(1000);

   Lista.Borrar(1500);

   Lista.Borrar(2000);

   Lista.Borrar(2500);

   Lista.Borrar(-500);

   Lista.Borrar(-1000);

   Lista.Borrar(-1500);

   Lista.Borrar(-2000);

   Lista.Borrar(-2500);

  

   Lista.Mostrar();

   cin.get();

   return 0;

}

LISTAS DOBLEMENTE  ENLAZADA                                                                                  

#include <iostream>

using namespace std;

#define ASCENDENTE 1

#define DESCENDENTE 0

class nodo {

   public:

    nodo(int v, nodo *sig = NULL, nodo *ant = NULL) :

       valor(v), siguiente(sig), anterior(ant) {}

   private:

    int valor;

    nodo *siguiente;

    nodo *anterior;

       

   friend class lista;

};

typedef nodo *pnodo;

class lista {

   public:

    lista() : plista(NULL) {}

    ~lista();

   

    void Insertar(int v);

    void Borrar(int v);

    bool ListaVacia() { return plista == NULL; }

    void Mostrar(int);

    void Siguiente();

    void Anterior();

    void Primero();

    void Ultimo();

    bool Actual() { return plista != NULL; }

    int ValorActual() { return plista->valor; }

   

   private:

    pnodo plista;

};

lista::~lista()

{

   pnodo aux;

  

   Primero();

   while(plista) {

      aux = plista;

      plista = plista->siguiente;

      delete aux;

   }

}

void lista::Insertar(int v)

{

   pnodo nuevo;

   Primero();

   // Si la lista está vacía

   if(ListaVacia() || plista->valor > v) {

      // Asignamos a lista un nuevo nodo de valor v y

      // cuyo siguiente elemento es la lista actual                   

      nuevo = new nodo(v, plista);

      if(!plista) plista = nuevo;

      else plista->anterior = nuevo;

   }

   else {

      // Buscar el nodo de valor menor a v

      // Avanzamos hasta el último elemento o hasta que el siguiente tenga

      // un valor mayor que v

      while(plista->siguiente && plista->siguiente->valor <= v) Siguiente();

      // Creamos un nuevo nodo después del nodo actual

      nuevo = new nodo(v, plista->siguiente, plista);

      plista->siguiente = nuevo;

      if(nuevo->siguiente) nuevo->siguiente->anterior = nuevo;

   }

}

void lista::Borrar(int v)

{

   pnodo nodo;

  

   nodo = plista;

   while(nodo && nodo->valor < v) nodo = nodo->siguiente;

   while(nodo && nodo->valor > v) nodo = nodo->anterior;

   if(!nodo || nodo->valor != v) return;

   // Borrar el nodo

  

   if(nodo->anterior) // no es el primer elemento

      nodo->anterior->siguiente = nodo->siguiente;

   if(nodo->siguiente) // no el el último nodo

      nodo->siguiente->anterior = nodo->anterior;

   delete nodo;

}

void lista::Mostrar(int orden)

{

   pnodo nodo;

   if(orden == ASCENDENTE) {

      Primero();

      nodo = plista;

      while(nodo) {

         cout << nodo->valor << "-> ";

         nodo = nodo->siguiente;

      }

   }

   else {

      Ultimo();

      nodo = plista;

      while(nodo) {

         cout << nodo->valor << "-> ";

         nodo = nodo->anterior;

      }

   }

   cout << endl;

}

void lista::Siguiente()

{

   if(plista) plista = plista->siguiente;

}

void lista::Anterior()

{

   if(plista) plista = plista->anterior;

}

void lista::Primero()

{

   while(plista && plista->anterior) plista = plista->anterior;

}

void lista::Ultimo()

{

   while(plista && plista->siguiente) plista = plista->siguiente;

}

int main()

{

   lista Lista;

  

   Lista.Insertar(500);

   Lista.Insertar(1000);

   Lista.Insertar(1500);

   Lista.Insertar(2000);

   Lista.Insertar(2500);

   Lista.Insertar(-500);

   Lista.Insertar(-1000);

   Lista.Insertar(-1500);

   Lista.Insertar(-2000);

   Lista.Insertar(-2500);

   Lista.Mostrar(ASCENDENTE);

   Lista.Mostrar(DESCENDENTE);

   Lista.Primero();

   cout << "Primero: " << Lista.ValorActual() << endl;

  

   Lista.Ultimo();

   cout << "Ultimo: " << Lista.ValorActual() << endl;

  

   Lista.Borrar(500);

   Lista.Borrar(1000);

   Lista.Borrar(1500);

   Lista.Borrar(2000);

   Lista.Borrar(2500);

   Lista.Borrar(-500);

   Lista.Borrar(-1000);

   Lista.Borrar(-1500);

   Lista.Borrar(-2000);

   Lista.Borrar(-2500);

   Lista.Mostrar(ASCENDENTE);

   Lista.Mostrar(DESCENDENTE);

   cin.get();

   return 0;

}

__________________________________________________________________

LISTAS CIRCULARES                                                                                                      

#include <iostream>

using namespace std;

class nodo {

   public:

    nodo(int v, nodo *sig = NULL)

    {

       valor = v;

       siguiente = sig;

    }

   private:

    int valor;

    nodo *siguiente;

       

   friend class lista;

};

typedef nodo *pnodo;

class lista {

   public:

    lista() { actual = NULL; }

    ~lista();

   

    void Insertar(int v);

    void Borrar(int v);

    bool ListaVacia() { return actual == NULL; }

    void Mostrar();

    void Siguiente();

    bool Actual() { return actual != NULL; }

    int ValorActual() { return actual->valor; }

   

   private:

    pnodo actual;

};

lista::~lista()

{

   pnodo nodo;

   // Mientras la lista tenga más de un nodo

   while(actual->siguiente != actual) {

      // Borrar el nodo siguiente al apuntado por lista

      nodo = actual->siguiente;

      actual->siguiente = nodo->siguiente;

      delete nodo;

   }

   // Y borrar el último nodo

   delete actual;

   actual = NULL;

}

void lista::Insertar(int v)

{

   pnodo Nodo;

   // Creamos un nodo para el nuevo valor a insertar

   Nodo = new nodo(v);

   // Si la lista está vacía, la lista será el nuevo nodo

   // Si no lo está, insertamos el nuevo nodo a continuación del apuntado

   // por lista

   if(actual == NULL) actual = Nodo;

   else Nodo->siguiente = actual->siguiente;

   // En cualquier caso, cerramos la lista circular

   actual->siguiente = Nodo;

}

void lista::Borrar(int v)

{

   pnodo nodo;

   nodo = actual;

   // Hacer que lista apunte al nodo anterior al de valor v

   do {

      if(actual->siguiente->valor != v) actual = actual->siguiente;

   } while(actual->siguiente->valor != v && actual != nodo);

   // Si existe un nodo con el valor v:

   if(actual->siguiente->valor == v) {

      // Y si la lista sólo tiene un nodo

      if(actual == actual->siguiente) {

         // Borrar toda la lista

         delete actual;

         actual = NULL;

      }

      else {

         // Si la lista tiene más de un nodo, borrar el nodo  de valor v

         nodo = actual->siguiente;

         actual->siguiente = nodo->siguiente;

         delete nodo;

      }

   }

}

void lista::Mostrar()

{

   pnodo nodo = actual;

   do {

      cout << nodo->valor << "-> ";

      nodo = nodo->siguiente;

   } while(nodo != actual);

   cout << endl;

}

void lista::Siguiente()

{

   if(actual) actual = actual->siguiente;

}

int main()

{

   lista Lista;

  

   Lista.Insertar(500);

   Lista.Insertar(1000);

   Lista.Insertar(1500);

   Lista.Insertar(2000);

   Lista.Insertar(2500);

   Lista.Insertar(-500);

   Lista.Insertar(-1000);

   Lista.Insertar(-1500);

   Lista.Insertar(-2000);

   Lista.Insertar(-2500);

   Lista.Mostrar();

   cout << "Lista de elementos:" << endl;

   Lista.Borrar(500);

   Lista.Borrar(1000);

   Lista.Mostrar();

   Lista.Insertar(-8000);

   Lista.Insertar(3500);

   Lista.Mostrar();

   cin.get();

   return 0;

}

___________________________________________________________

CORPORACIÓN IBEROAMERICANA DE ESTUDIOS

MATERIA:
ESTRUCTURA DE DATOS


INTEGRANTES DEL TRABAJO:

• LICETH REPIZO PRADA
• NILSON HUERFANO
• FABIAN IBAÑEZ

MAESTRO:

• JORGE RODRIGUEZ

JORNADA:
SÁBADOS 8AM-12PM

ESTRUCTURA DE DATOS

                           MATRICES                         

Indica las coordenadas X,Y

#include <stdio.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

    int x,y,num=2, numeros[3][3];

  

    for (x=0;x<3;x++)

    {

        for (y=0;y<3;y++)

        {

            numeros[x][y]=num;

            num=num*2;

        }

    }

   printf("Introduzca coordenada x: ");

    scanf("%d",&x);

    printf("Introduzca coordenada y: ");

    scanf("%d",&y);

  

    printf("El número es: %d\n",numeros[x][y]);

  

    system("PAUSE");    

    return 0;

}                                                                                                                                                 

 __________________________________________________________________________

MUESTRA LOS VALORES INGRESADOS EN CADA FILA Y COLUMNA

#include<iostream>

#include<stdlib.h>

using namespace std;

main(){

                int fila, columna;

                cout<<"Numero de filas"<<endl;

                cin>>fila;

                cout<<"Numero de columnas"<<endl;

                cin>>columna;

//Se declara la matriz

int matriz[fila][columna];

//Se llena la matriz

               

                for(int i=0;i<fila;i++){

                               for(int j=0;j<columna;j++){

                                               cout<<endl<<"Digite los valores"<<i+1<<","<<j+1<<" ";

                                               cin>>matriz[i][j];

                               }

                }

                cout<<endl<<"   Impresion matriz"<<endl;

// Imprimir matriz

                for(int k=0;k<fila;k++){

                               for (int l=0;l<columna;l++){

                                               cout<<matriz[k][l];

                               }

                cout<<endl;

}

system("pause");

}

 ________________________________________________________________________________________

MUESTRA EL NUMERO MAYOR Y EL NUMERO MENOR INDICANDO SU POSICIÓN 

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

main (){

 int num, i, j;

 int tablanum[3][3]={0};

 int t[3][3]={0};

 int may, fmax=0, cmax=0, min, fmin=0, cmin=0;

 for (i=0;i<3;i++)

 {

 for (j=0;j<3;j++)

 {

 printf ("Introduce un numero: ");

 scanf ("%d", &tablanum[i][j]);

 }

 }

 may= tablanum[0][0];

 min= tablanum[0][0];

 for (i=0;i<3;i++)

 {

 for (j=0;j<3;j++)

 {

 if (tablanum[i][j]>may)

 {

 may=tablanum[i][j];

 fmax=i;

 cmax=j;

 }

}

}

 if (tablanum [i][j]<min)

 {

 min=tablanum[i][j];

 fmin=i;

 cmin=j;

 }

  printf ("El mayor es: %d y su posicion es: %d fila y %d columna\n", may, fmax,

cmax);

 printf ("El menor es: %d y su posicion es: %d fila y %d columna\n", min, fmin,

cmin);

system("PAUSE");

}

                    

_______________________________________________________________________________

_______________________________________________________________________________

                               VECTORES                                      

MUESTRA EL VALOR MÁXIMO INGRESADO 

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

#define N 6

int main ()

{

     int vect [N];

     int i,maxim=0,pos;

     for(i=0;i<N;i++)

     {

     printf("introduce el valor de la posicion %d:", i);

     scanf("%d", &vect[i]);

     }

     for(i=0;i<N;i++)

     {

        if(vect[i]>maxim)             

        {

           maxim=vect[i];pos=i;

        }

     }

    printf("El maximo es %d.",vect[pos]);

    system("PAUSE");

    }

______________________________________________________________________________________

NOS GENERA LA SUMA DE LOS NÚMEROS INGRESADOS:

#include <stdio.h>

#include <stdlib.h>

int main(void)

{

            int x,tabla[10];

            int sum;

          

            for (x=0;x<10;x++)

            {

        printf("Introduzca numero\n");

        scanf("%d",&tabla[x]);

    }

          

            sum=tabla[0];

   

            for (x=1;x<10;x++)

            {

        sum=sum+tabla[x];

 }

           printf("Suma: %d\n",sum);

          

    system("PAUSE");    

    return 0;

}

_________________________________________________________________________________________________

 NOS GENERA LA RESTA DE LOS NÚMEROS INGRESADOS:

#include <stdio.h>

#include <stdlib.h>

int main(void)

{

            int x,tabla[10];

            int res;

          

            for (x=0;x<10;x++)

            {

        printf("Introduzca numero\n");

        scanf("%d",&tabla[x]);

    }

          

    res=tabla[0];

          

            for (x=1;x<10;x++)

            {

        res=res-tabla[x];

    }

         printf("Resultado Resta: %d\n",res);

       

    system("PAUSE");    

    return 0;

}


CORPORACIÓN IBEROAMERICANA DE ESTUDIOS

MATERIA:
ESTRUCTURA DE DATOS


INTEGRANTES DEL TRABAJO:

• LICETH REPIZO PRADA
• NILSON HUERFANO
• FABIAN IBAÑEZ

MAESTRO:

• JORGE RODRIGUEZ

JORNADA:
SÁBADOS 8AM-12PM