Raquel López

Just another WordPress.com weblog

ESTRUCTURAS_Punteros_Listas_Enlazadas_Dobles_Circulares

//Estas son las listas enlazadas simples

CONSEPTO:

Listas enlazadas simples

La lista enlazada básica es la lista enlazada simple la cual tiene un enlace por nodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL (apunta a tierra) o a la lista vacía, si es el último nodo.

Singly-linked-list.svg
Una lista enlazada simple contiene dos valores: el valor actual del nodo y un enlace al siguiente nodoCodigo Fuente     /*********LISTAS ENLAZADAS SIMPLES********/
#include<iostream.h>
#include<conio.h>
#include<math.h>
#include<string.h>
#include<stdio.h>
#include<fcntl.h>
#include<io.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys\stat.h>
#include<io.h>
#include<process.h>
#include<alloc.h>
#include”iomanip.h”

 
//ESTRUCTURA CON NODOS
typedef struct nodo
{
    int num;
    struct nodo *sig;

}tipoNodo;
 //DECLARACION DE LOS PORTOTIPOS

 void menupuntero();
 void presentar();

 //PARA UZAR LOS PUNTEROS
 tipoNodo *crearNuevo();
 void crear();
 void nuevo();
 void modificar();
 void buscar();
 void eliminacion();
 void eliminarcabeza();
 void eliminar();
 void ordenar();
 void as();
 void des();
 void oras();
 void ordes();
 void insertar();
 void insertar_ordenado();
 void insertar_cabeza();
 void insertar_final();
 void presentar();
 tipoNodo *cab;

 //OPCION BUSCAR
 void busquedaC();

 //CONSTANTES
 const npun=20;
 //FUNCION PRINCIPAL
 void main()
 {
    menupuntero();

 }
 //CONPARTIMINETO DEL PROYECTO

 //MENUS DE PRESENTACION

 void menupuntero()
 {
    textmode(BW80);
    cprintf(“ABC”);

  char opl=’0′;
  do
  {
     clrscr();
   cout<<“\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<“\t\tº***MENU LISTAS ENLAZADAS***     º\n”;
   cout<<“\t\tº                                º\n”;
   cout<<“\t\tº [1]  CREAR                     º\n”;
   cout<<“\t\tº [2]  NUEVO                     º\n”;
   cout<<“\t\tº [3]  MODIFICAR                 º\n”;
   cout<<“\t\tº [4]  BUSCAR                    º\n”;
   cout<<“\t\tº [5]  ELIMINAR                  º\n”;
   cout<<“\t\tº [6]  ORDENAR                   º\n”;
   cout<<“\t\tº [7]  INSERTAR                  º\n”;
   cout<<“\t\tº [8]  PRESENTAR                 º\n”;
   cout<<“\t\tº [x]  SALIR                     º\n”;
   cout<<“\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<“SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1’ :crear();break;
 case ‘2’ :nuevo(); break;
 case ‘3’ :modificar(); break;
 case ‘4’ :buscar(); break;
 case ‘5’ :eliminacion(); break;
 case ‘6’ :ordenar(); break;
 case ‘7’ :insertar(); break;
 case ‘8’ :presentar(); break;

 
   }

  }
 while(opl!=’x’);
}
 //PARA EL MANEJO DE LAS LISZTAS ENLAZADAS

 //ME PERMITE CREAR CABEZA

void crear()
{
   textcolor(4);
  clrscr();
  cab=crearNuevo();
  cout<<“INGRESE CABEZA:\t”;
  cin>>cab->num;
  cab->sig=NULL;

 

 

}
//ME PERMITE INGRESAR UN NUEVO NUMERO

void nuevo()
{
   textcolor(41);
  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<“INGRESE VALOR:\t”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)
  {
    recorrer= recorrer->sig;
  }
  recorrer->sig=elem;
  elem->sig=NULL;

}

//ESTA OPCION ME PERMINTE MODIFICAR

void modificar()
{

    textcolor(42);
    clrscr();
    tipoNodo * elem,* nuevo;
    elem=crearNuevo();
    cout<<“INGRESE VALOR QUE SE VA HA MODIFICAR:\t “;
    cin>>elem->num;
    // elem->sig=NULL;
    tipoNodo * recorrer;
    recorrer=cab;
    while(recorrer->sig == elem)
    cout<<“INGRESE NUMERO:\t”;
    cin>>nuevo->num;
    recorrer=recorrer->sig;
    recorrer->sig=elem;
    elem->sig=NULL;
}

//ME PERMIOTE BUSCAR

void buscar()
{
    textcolor(30);
   clrscr();
   tipoNodo *elem;
   int x;
   cout<<“VALOR QUE VA A BUSCAR:\t”;
   cin>>x;
   while(elem!=NULL && elem->num!=x)
   {
      elem=elem->sig;
   }

}
//ESTE MENU ES DE ELIMINACION

void eliminacion()
{
  char opl=’0′;
  do
  {
     clrscr();
   cout<<“\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<“\t\tº***MENU LISTAS ENLAZADAS**      º\n”;
   cout<<“\t\tº                                º\n”;
   cout<<“\t\tº 1.-  ELIMINAR                  º\n”;
   cout<<“\t\tº 2.-  ELIMINAR CABEZA           º\n”;
   cout<<“\t\tº x.-  SALIR                     º\n”;
   cout<<“\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<“SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1’ :eliminar();break;
 case ‘2’ :eliminarcabeza(); break;

   }

  }
 while(opl!=’x’);

}

//ME PERMITE ELIMINAR CABEZA
void eliminarcabeza()
{
    clrscr();
    tipoNodo *aux;
    cab=cab->sig;
    aux->sig=NULL;
    free(aux);
}

//ME PERMITE ELIMINAR UNO DE LOS NUMEROS INGRESADOS

void eliminar()
{
   clrscr();
   tipoNodo *aux;
   int n;
   cout<<“INGRESE ELEMENTO QUE VA HA ELIMINAR:\t”;
   cin>>n;
    if(n==cab->num)
  eliminarcabeza();
    else{
     tipoNodo *ant=cab;
     aux=cab->sig;
     while((aux!=NULL)&&(aux->num!=n))
     {
       ant=aux;
       aux=aux->sig;

     }
     if(aux!=NULL)
     {
 ant->sig=aux->sig;
 aux->sig=NULL;
 free(aux);

     }
     else
       cout<<“NO SE ENCUENTRA”;

    }

}

//ESTA OPCION ES DE ORDENAMIENTO

void ordenar()
{

   textcolor(3);
  char opl=’0′;
  do
  {
     clrscr();
   cout<<“\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<“\t\tº***MENU LISTAS ENLAZADAS**      º\n”;
   cout<<“\t\tº                                º\n”;
   cout<<“\t\tº 1.-  ORDENAMIENTO ASCENDENTE   º\n”;
   cout<<“\t\tº 2.-  ORDENAMIENTO DESCENDENTE  º\n”;
   cout<<“\t\tº x.-  SALIR                     º\n”;
   cout<<“\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<“SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1’ :as();break;
 case ‘2’ :des(); break;

   }

  }
 while(opl!=’x’);
}

//ME PERMITE ORDENAR DE FORMA ASCENDENTE
void as()
{
   clrscr();
   tipoNodo *aux,*aux1;
   int b;
   aux=cab;
   while(aux!=NULL)
   {
     aux1=aux;
     aux1=aux1->sig;
     while(aux1!=NULL)
     {
       if(aux->num>aux1->num)
       {
  b=aux1->num;
  aux1->num=aux->num;
  aux->num=b;
  aux1=aux1->sig;
       }
       else
       {
   aux1=aux1->sig;
       }
     }
     aux=aux->sig;
   }
}
void oras()
{
  as();
  clrscr();
  tipoNodo *aux;
  int w;
  aux = cab;
  w=10;
  while (aux!= NULL)
  {
    gotoxy(15,8);cout<<“ORDENACION ASCENDENTE”;
    gotoxy(w,10);
    cout<< aux->num;
    aux = aux->sig;
    w=w+5;
  }
  getch();

}
void des()
{
  clrscr();
  tipoNodo *aux,*aux1;
  int b;
  aux=cab;
  while(aux1!=NULL)
  {
    aux1=aux;
    aux1=aux1->sig;
    while(aux1!=NULL)
    {
      if(aux->num>aux1->num)
      {
 b=aux1->num;
 aux1->num=aux->num;
 aux->num=b;
 aux1=aux1->sig;
      }
      else
      {
 aux1=aux1->sig;
      }
    }
    aux=aux->sig;
  }
}

 

void ordes()
{

  des();
  tipoNodo *aux;
  int w;
  aux = cab;
  w=10;
  while (aux!= NULL)
  {
    gotoxy(15,8);cout<<“ORDENACION DESCENDENTE”;
    gotoxy(w,10);
    cout<< aux->num;
    aux = aux->sig;
    w=w+5;
  }
  getch();

}
//ESTA OPCION ME PERMITE INSERTAR

void insertar()
{
    textcolor(5);
   char opl=’0′;
  do
  {
     clrscr();
   cout<<“\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<“\t\tº***MENU LISTAS ENLAZADAS**      º\n”;
   cout<<“\t\tº                                º\n”;
   cout<<“\t\tº 1.-  INSERTAR ORDENADO         º\n”;
   cout<<“\t\tº 2.-  INSERTAR FINAL            º\n”;
   cout<<“\t\tº 3.-  INSERTAR CABEZA           º\n”;
   cout<<“\t\tº x.- SALIR                      º\n”;
   cout<<“\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<“SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1’ :insertar_ordenado();break;
 case ‘2’ :insertar_final(); break;
 case ‘3’ :insertar_cabeza(); break;
   }

  }
 while(opl!=’x’);

}
//ME PERMITE INSERTAR UN NUMERO PERO YA ORDENADO

void insertar_ordenado()
{

  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<“INGRESE UN VALOR:\t”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)
  {
    recorrer= recorrer->sig;
  }
  recorrer->sig=elem;
  elem->sig=NULL;

  as();
  oras();

 

}

//ME PERMITE INSERTAR UN NUMERO AL FINAL
void insertar_final()
{
  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<“INGRESE EL VALOR FINAL:\t”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)
  {
    recorrer= recorrer->sig;
  }
  recorrer->sig=elem;
  elem->sig=NULL;

}

//ME PERMITE INSERTAR UNA NUEVA CABEZA
void insertar_cabeza()
{
   cab=crearNuevo();
  cout<<“INGRESE CABEZA:\t”;
  cin>>cab->num;
  cab->sig=NULL;

}
/*ESTA OPCION ME PERMITE PRESENTAR TODOS LOS NUMEROS
 QUE INGRESE, ELIMINE ORDENE Y INSERTE*/

void presentar()
{
   textcolor(6);
  clrscr();
  tipoNodo *recorrer;
  recorrer=cab;
  while(recorrer!=NULL)
  {
   cout<<recorrer->num;
    recorrer=recorrer->sig;
  }
  getch();
}
tipoNodo *crearNuevo()

{
   tipoNodo *nodo1;
   nodo1 =(tipoNodo*)malloc(sizeof(tipoNodo)) ;
   if(!nodo1)
   cout<<“No se ha reservado memoria\n”;
   return nodo1; //devuelve la direccion de la memoria reservada
}

//Listas Dobles

CONSEPTO

Lista Doblemente Enlazada

Un tipo de lista enlazada más sofisticado es la lista doblemente enlazada o lista enlazadas de dos vías. Cada nodo tiene dos enlaces: uno apunta al nodo anterior, o apunta al valor NULL o a las lista vacía si es el primer nodo; y otro que apunta al siguiente nodo siguiente, o apunta al valor NULL o a la lista vacía si es el último nodo.

Doubly-linked-list.svg
Una lista doblemente enlazada contiene tres valores: el valor, el link al nodo siguiente, y el link al anteriorCODIGO FUENTE    

 /*********LISTAS DOBLES********/
#include<iostream.h>
#include<conio.h>
#include<math.h>
#include<string.h>
#include<stdio.h>
#include<fcntl.h>
#include<io.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys\stat.h>
#include<io.h>
#include<process.h>
#include<alloc.h>
#include”iomanip.h”

 
//ESTRUCTURA CON NODOS
typedef struct nodo
{
    int num;
    struct nodo *sig,*ante;

}tipoNodo;
 //DECLARACION DE LOS PORTOTIPOS

 void menupuntero();
 void presentar();

 //PARA UZAR LOS PUNTEROS
 tipoNodo *crearNuevo();
 void crear();
 void nuevo();
 void modificar();
 void buscar();
 void eliminacion();
 void eliminarcabeza();
 void eliminar();
 void ordenar();
 void as();
 void des();
 void oras();
 void ordes();
 void insertar();
 void insertar_ordenado();
 void insertar_cabeza();
 void insertar_final();
 void presentar();
 tipoNodo *cab;
  tipoNodo *cola;

 //OPCION BUSCAR
 void busquedaC();

 //CONSTANTES
 const npun=20;
 //FUNCION PRINCIPAL
 void main()
 {
    menupuntero();

 }
 //CONPARTIMINETO DEL PROYECTO

 //MENUS DE PRESENTACION

 void menupuntero()
 {
    textmode(BW80);
    cprintf(“ABC”);

  char opl=’0′;
  do
  {
     clrscr();
   cout<<“\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<“\t\tº**MENU LISTAS ENLAZADAS DOBLES  º\n”;
   cout<<“\t\tº                                º\n”;
   cout<<“\t\tº [1]  CREAR                     º\n”;
   cout<<“\t\tº [2]  NUEVO                     º\n”;
   cout<<“\t\tº [3]  MODIFICAR                 º\n”;
   cout<<“\t\tº [4]  BUSCAR                    º\n”;
   cout<<“\t\tº [5]  ELIMINAR                  º\n”;
   cout<<“\t\tº [6]  ORDENAR                   º\n”;
   cout<<“\t\tº [7]  INSERTAR                  º\n”;
   cout<<“\t\tº [8]  PRESENTAR                 º\n”;
   cout<<“\t\tº [x]  SALIR                     º\n”;
   cout<<“\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<“SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1’ :crear();break;
 case ‘2’ :nuevo(); break;
 case ‘3’ :modificar(); break;
 case ‘4’ :buscar(); break;
 case ‘5’ :eliminacion(); break;
 case ‘6’ :ordenar(); break;
 case ‘7’ :insertar(); break;
 case ‘8’ :presentar(); break;

 
   }

  }
 while(opl!=’x’);
}
 //PARA EL MANEJO DE LAS LISZTAS ENLAZADAS DOBLES

 //ME PERMITE CREAR CABEZA

void crear()
{
   textcolor(4);

   clrscr();
   cab=NULL;
   cab=crearNuevo();
   cout<<“INGRESE CABEZA:\t”;
   cin>>cab->num;
   cab->ante=NULL;
   cab->sig=NULL;
   cola=cab;

 

     }
//ME PERMITE INGRESAR UN NUEVO NUMERO

void nuevo()
{
   textcolor(41);
  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<“INGRESE VALOR:”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)

    recorrer= recorrer->sig;

  recorrer->sig=elem;
  elem->sig=NULL;

}

//ESTA OPCION ME PERMINTE MODIFICAR

void modificar()
{

    textcolor(42);
    clrscr();
    tipoNodo * elem,* nuevo;
    elem=crearNuevo();
    cout<<“INGRESE VALOR QUE SE VA HA MODIFICAR:\t “;
    cin>>elem->num;
    // elem->sig=NULL;
    tipoNodo * recorrer;
    recorrer=cab;
    while(recorrer->sig == elem)
    cout<<“INGRESE NUMERO:\t”;
    cin>>nuevo->num;
    recorrer=recorrer->sig;
    recorrer->sig=elem;
    elem->sig=NULL;
}

//ME PERMIOTE BUSCAR

void buscar()
{
    textcolor(30);
   clrscr();
   tipoNodo *elem;
   int x;
   cout<<“VALOR QUE VA A BUSCAR:\t”;
   cin>>x;
   while(elem!=NULL && elem->num!=x)
   {
      elem=elem->sig;
   }

}
//ESTE MENU ES DE ELIMINACION

void eliminacion()
{
  char opl=’0′;
  do
  {
     clrscr();
   cout<<“\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<“\t\tº***MENU LISTAS ENLAZADAS**      º\n”;
   cout<<“\t\tº                                º\n”;
   cout<<“\t\tº 1.-  ELIMINAR                  º\n”;
   cout<<“\t\tº 2.-  ELIMINAR CABEZA           º\n”;
   cout<<“\t\tº x.-  SALIR                     º\n”;
   cout<<“\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<“SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1’ :eliminar();break;
 case ‘2’ :eliminarcabeza(); break;

   }

  }
 while(opl!=’x’);

}

//ME PERMITE ELIMINAR CABEZA
void eliminarcabeza()
{
    clrscr();
    tipoNodo *aux;
    cab=cab->sig;
    aux->sig=NULL;
    free(aux);
}

//ME PERMITE ELIMINAR UNO DE LOS NUMEROS INGRESADOS

void eliminar()
{
   clrscr();
   tipoNodo *aux;
   int n;
   cout<<“INGRESE ELEMENTO QUE VA HA ELIMINAR:\t”;
   cin>>n;
    if(n==cab->num)
  eliminarcabeza();
    else{
     tipoNodo *ant=cab;
     aux=cab->sig;
     while((aux!=NULL)&&(aux->num!=n))
     {
       ant=aux;
       aux=aux->sig;

     }
     if(aux!=NULL)
     {
 ant->sig=aux->sig;
 aux->sig=NULL;
 free(aux);

     }
     else
       cout<<“NO SE ENCUENTRA”;

    }

}

//ESTA OPCION ES DE ORDENAMIENTO

void ordenar()
{

   textcolor(3);
  char opl=’0′;
  do
  {
     clrscr();
   cout<<“\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<“\t\tº***MENU LISTAS ENLAZADAS**      º\n”;
   cout<<“\t\tº                                º\n”;
   cout<<“\t\tº 1.-  ORDENAMIENTO ASCENDENTE   º\n”;
   cout<<“\t\tº 2.-  ORDENAMIENTO DESCENDENTE  º\n”;
   cout<<“\t\tº x.-  SALIR                     º\n”;
   cout<<“\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<“SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1’ :as();break;
 case ‘2’ :des(); break;

   }

  }
 while(opl!=’x’);
}

//ME PERMITE ORDENAR DE FORMA ASCENDENTE
void as()
{
   clrscr();
   tipoNodo *aux,*aux1;
   int b;
   aux=cab;
   while(aux!=NULL)
   {
     aux1=aux;
     aux1=aux1->sig;
     while(aux1!=NULL)
     {
       if(aux->num>aux1->num)
       {
  b=aux1->num;
  aux1->num=aux->num;
  aux->num=b;
  aux1=aux1->sig;
       }
       else
       {
   aux1=aux1->sig;
       }
     }
     aux=aux->sig;
   }
}
void oras()
{
  as();
  clrscr();
  tipoNodo *aux;
  int w;
  aux = cab;
  w=10;
  while (aux!= NULL)
  {
    gotoxy(15,8);cout<<“ORDENACION ASCENDENTE”;
    gotoxy(w,10);
    cout<< aux->num;
    aux = aux->sig;
    w=w+5;
  }
  getch();

}
void des()
{
  clrscr();
  tipoNodo *aux,*aux1;
  int b;
  aux=cab;
  while(aux1!=NULL)
  {
    aux1=aux;
    aux1=aux1->sig;
    while(aux1!=NULL)
    {
      if(aux->num>aux1->num)
      {
 b=aux1->num;
 aux1->num=aux->num;
 aux->num=b;
 aux1=aux1->sig;
      }
      else
      {
 aux1=aux1->sig;
      }
    }
    aux=aux->sig;
  }
}

 

void ordes()
{

  des();
  tipoNodo *aux;
  int w;
  aux = cab;
  w=10;
  while (aux!= NULL)
  {
    gotoxy(15,8);cout<<“ORDENACION DESCENDENTE”;
    gotoxy(w,10);
    cout<< aux->num;
    aux = aux->sig;
    w=w+5;
  }
  getch();

}
//ESTA OPCION ME PERMITE INSERTAR

void insertar()
{
    textcolor(5);
   char opl=’0′;
  do
  {
     clrscr();
   cout<<“\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<“\t\tº***MENU LISTAS ENLAZADAS**      º\n”;
   cout<<“\t\tº                                º\n”;
   cout<<“\t\tº 1.-  INSERTAR ORDENADO         º\n”;
   cout<<“\t\tº 2.-  INSERTAR FINAL            º\n”;
   cout<<“\t\tº 3.-  INSERTAR CABEZA           º\n”;
   cout<<“\t\tº x.- SALIR                      º\n”;
   cout<<“\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<“SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1’ :insertar_ordenado();break;
 case ‘2’ :insertar_final(); break;
 case ‘3’ :insertar_cabeza(); break;
   }

  }
 while(opl!=’x’);

}
//ME PERMITE INSERTAR UN NUMERO PERO YA ORDENADO

void insertar_ordenado()
{

  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<“INGRESE UN VALOR:\t”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)
  {
    recorrer= recorrer->sig;
  }
  recorrer->sig=elem;
  elem->sig=NULL;

  as();
  oras();

 

}

//ME PERMITE INSERTAR UN NUMERO AL FINAL
void insertar_final()
{
  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<“INGRESE EL VALOR FINAL:\t”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)
  {
    recorrer= recorrer->sig;
  }
  recorrer->sig=elem;
  elem->sig=NULL;

}

//ME PERMITE INSERTAR UNA NUEVA CABEZA
void insertar_cabeza()
{

   tipoNodo *elem;
  elem=crearNuevo();
  cout<<“INGRESE NUEVA CABEZA:”;
  cin>>elem->num;
  cab->ante = elem;
  elem->sig = cab;
  elem->ante = NULL;
  cab = elem;

 

}
/*ESTA OPCION ME PERMITE PRESENTAR TODOS LOS NUMEROS
 QUE INGRESE, ELIMINE ORDENE Y INSERTE*/

void presentar()
{
   textcolor(6);
  clrscr();
  tipoNodo *recorrer;
  recorrer=cab;
  while(recorrer!=NULL)
  {
   cout<<recorrer->num;
    recorrer=recorrer->sig;
  }
  getch();
}
tipoNodo *crearNuevo()

{
   tipoNodo *nodo1;
   nodo1 =(tipoNodo*)malloc(sizeof(tipoNodo)) ;
   if(!nodo1)
   cout<<“No se ha reservado memoria\n”;
   return nodo1; //devuelve la direccion de la memoria reservada
}

LISTAS CIRCULARES

CONSEPTO

Listas enlazadas circulares

En una lista enlazada circular, el primer y el último nodo están unidos juntos. Esto se puede hacer tanto para listas enlazadas simples como para las doblemente enlazadas. Para recorrer un lista enlazada circular podemos empezar por cualquier nodo y seguir la lista en cualquier dirección hasta que se regrese hasta el nodo original. Desde otro punto de vista, las listas enlazadas circulares pueden ser vistas como listas sin comienzo ni fin. Este tipo de listas es el más usado para dirigir buffers para “ingerir” datos, y para visitar todos los nodos de una lista a partir de uno dado.

Circularly-linked-list.svg
Una lista enlazada circular que contiene tres valores enterosCODIGO FUENTE

#include<iostream.h>
#include<conio.h>
#include<math.h>
#include<string.h>
#include<stdio.h>
#include<fcntl.h>
#include<io.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys\stat.h>
#include<io.h>
#include<process.h>
#include<alloc.h>

 

//ESTRUCTURA CON NODOS
typedef struct nodo
{
    int num;
    struct nodo *sig;
    struct nodo *ante;
}tipoNodo;
 //declaracion de prototipos

 void menupuntero();
 void presentar();

 //Para el manejo de punteros
 tipoNodo *crearNuevo();
 void crear();
 void nuevo();
 void modificar();
 void buscar();
 void eliminarcabeza();
 void eliminar();
 void ordenar();
 void insertar_ordenado();
 void insertar_cabeza();
 void insertar_final();
 void presentar();
 tipoNodo *cab;
 tipoNodo *cola;
 //busqueda del puntero
 void busquedaC();

 //Constantes
 const npun=20;
 //Variables Globales
// puntero pun[npun];

 //funcion principal
 void main()
 {
    menupuntero();
 }
 //compartimiento del proyecto
 //menus de presentacion

 void menupuntero()
 {
  char opl=’0′;
  do
  {
     clrscr();
   cout<<“\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<“\t\tº***MENU LISTAS ENLAZADAS**      º\n”;
   cout<<“\t\tº                                º\n”;
   cout<<“\t\tº 1.  CREAR                      º\n”;
   cout<<“\t\tº 2.  NUEVO                      º\n”;
   cout<<“\t\tº 3.  MODIFICAR                  º\n”;
   cout<<“\t\tº 4.  BUSCAR                     º\n”;
   cout<<“\t\tº 5.  ELIMINAR CABEZA            º\n”;
   cout<<“\t\tº 6.  ORDENAR                    º\n”;
   cout<<“\t\tº 7.  PRESENTAR                  º\n”;
   cout<<“\t\tº 8.  ELIMINAR                   º\n”;
   cout<<“\t\tº 9.  INSERTAR ORDENADO          º\n”;
   cout<<“\t\tº a.  INSERTAR CABEZA        º\n”;
   cout<<“\t\tº b.  INSERTAR FINAL             º\n”;
   cout<<“\t\tº x.  SALIR                      º\n”;
   cout<<“\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<“SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1’ :crear();break;
 case ‘2’ :nuevo(); break;
 case ‘3’ :modificar(); break;
 case ‘4’ :buscar(); break;
 case ‘5’ :eliminarcabeza(); break;
 case ‘6’ :ordenar(); break;
 case ‘7’ :presentar(); break;
 case ‘8’ :eliminar(); break;
 case ‘9’ :insertar_ordenado(); break;
 case ‘a’ :insertar_cabeza(); break;
 case ‘b’ :insertar_final(); break;

 
   }

  }
 while(opl!=’x’);
}
 //PARA EL MANEJO DE LOS PUNTEROS

void crear()

{
   cab=NULL;

   cab=crearNuevo();
   cout<<“INGRESE CABEZA:”;
   cin>>cab->num;
   cab->sig=cab;
  cab->ante=cab;
  cola=cab;
}

void nuevo()
{

   tipoNodo *elem;
  elem=crearNuevo();
  cout<<“INGRESE VALOR:”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=cab)

  recorrer= recorrer->sig;

  recorrer->sig=elem;
  elem->sig=cab;
  getch();
}

 

void modificar()
{

    clrscr();
    tipoNodo * elem,* nuevo;
    elem=crearNuevo();
    cout<<“INGRESE VALOR QUE SE VA HA MODIFICAR: “;
    cin>>elem->num;
    // elem->sig=NULL;
    tipoNodo * recorrer;
    recorrer=cab;
    while(recorrer->sig == elem)
    cout<<“INGRESE NUMERO:”;
    cin>>nuevo->num;
    recorrer=recorrer->sig;
    recorrer->sig=elem;
    elem->sig=NULL;
}

 

void buscar()
{
   tipoNodo *elem;
   int x;
   cout<<“VALOR QUE VA A BUSCAR:”;
   cin>>x;
   while(elem!=NULL && elem->num!=x)
   {
      elem=elem->sig;
   }

}

 

void eliminarcabeza()
{
    tipoNodo *aux;
    cab=cab->sig;
    aux->sig=NULL;
    free(aux);
}

 

void eliminar()
{
   tipoNodo *aux;
   int n;
   cout<<“INGRESE ELEMENTO QUE VA HA ELIMINAR:”;
   cin>>n;
    if(n==cab->num)
  eliminarcabeza();
    else{
     tipoNodo *ant=cab;
     aux=cab->sig;
     while((aux!=NULL)&&(aux->num!=n))
     {
       ant=aux;
       aux=aux->sig;

     }
     if(aux!=NULL)
     {
 ant->sig=aux->sig;
 aux->sig=NULL;
 free(aux);

     }
     else
       cout<<“NO SE ENCUENTRA:”;

    }
}

 

void ordenar()
{
 // int aux1;
 tipoNodo *aux,*aux1;
 aux=cab;
 while(aux->sig!=NULL)
 {
      aux1=aux->sig;
  while(aux1!=NULL)
  {
   //aux1=aux->sig;
   int naux=0;
   if(aux->num <aux1->num)
   {
    naux=aux->num;
    aux->num=aux1->num;
    aux->num=naux;
   }
   aux1=aux1->sig;
  }
  aux=aux->sig;
 }

       /* aux=crearNuevo();
 tem=crearNuevo();
 aux=cab;
 tem=aux;
 while(aux!=NULL){
  tem=aux;
  while(tem->sig!=NULL){
   tem=tem->sig;
   if(aux->num>tem->num){
    aux2=aux->num;
    aux->num=tem->num;
    tem->num=aux2;
   }
  }
  aux=aux->sig; */
 }
//getch();

 

 

void insertar_ordenado()
{
  tipoNodo *ant;
  tipoNodo *aux;
int n;
 //cout<<“INGRESE NUMERO A ORDENAR:”
// cin>>n;
  if(n>cab->num)
       // insertar_cabeza(n);

  // else
      ant = cab;
      aux = cab->sig;
  while((aux!=NULL) && (n<aux->num))
   {
     ant = aux;
     aux = aux->sig;
   }
   nodo *nuevo;
   nuevo = crearNuevo();
   nuevo->num =n;
   ant->sig = nuevo;
   nuevo->sig = aux;

}
void insertar_final()
{
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<“INGRESE EL VALOR AL FINAL:”;
  cin>>elem->num;
  cola->sig = elem;
  elem->ante = cola;
  elem->sig = cab;
  cola = elem;
/*  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)

    recorrer= recorrer->sig;

  recorrer->sig=elem;
  elem->sig=NULL;  */
 // getch();

}
void insertar_cabeza()
{
 tipoNodo *elem;
  elem=crearNuevo();
  cout<<“INGRESE EL VALOR A INSERTAR:”;
  cin>>elem->num;
  cab->ante = elem;
  elem->sig = cab;
  elem->ante = NULL;
  cab = elem;
}

 
void presentar()
{
  tipoNodo * aux;
  aux = cab;
  for(int c=0;c<=1;c++)
  {
    cout<<” “<<aux->num; aux=aux->sig;
      while(aux!=cab)
      {
 cout<<aux->num;
 aux=aux->sig;
      }
  }

 

 
 /*
  tipoNodo *recorrer;
  recorrer=cab;
  while(recorrer!=NULL)
  {
    cout<<” “<<recorrer->num;
    recorrer=recorrer->sig;
  }
 //  insertar_final();  */
  getch();
}

 

tipoNodo *crearNuevo()

{
   tipoNodo *nodo1;
   nodo1 =(tipoNodo*)malloc(sizeof(tipoNodo)) ;
   if(!nodo1)
   cout<<“No se ha reservado memoria\n”;
   return nodo1; //devuelve la direcc. de la memoria reservada
}

No comments yet»

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: