Prácticas a desarrollar de Lista Circulares Doblemente Enlazadas.

Practica 1. Mediante el uso de listas circulares doblemente enlazadas realiza un Programa que devuelva la Multiplicación de los Números introducidos en los Nodos de la Lista circular.

Practica 2. Escribir un Programa que devuelva los Números Pares e Impares que se encuentran en los Nodos de una Lista.

Practica 3. Desarrollar un Programa que dada una Lista circular doblemente Enlazada ordene los Nodos en forma Ascendente.

Recursividad

La recursion o recursividad es un concepto amplio, con muchas variantes, y difícil de precisar con pocas palabras.
Un objeto recursivo es aquel que aparece en la definición de si mismo, así como el que se llama así mismo.
La recursion se puede presentar de dos maneras diferentes:
Directa:El programa o subprograma se llaman directamente a si mismo.
Indirecta: El subprograma llama a otro programa y este, en algún momento, llama nuevamente al primero.

Listas doblemente ligadas circulares

Tomar el siguiente apunte en su cuaderno para revisión el 28 de Septiembre 2016

 

Listas doblemente ligadas circulares

 

En las listas ligadas circulares, el campo liga izquierda del primer nodo de la lista apunta al ultimo y el campo liga derecha de este apunta al primero. La siguiente figura representa una estructura de este tipo:

Espacio para figura

 

 

La principal ventaja de las listas circulares es que permite la navegación en cualquier sentido a través  de la misma y, además, se puede recorrer toda la lista partiendo de cualquier nodo, siempre que tengamos un apuntador a este. Sin embargo debemos destacar que es necesario establecer condiciones adecuadas para detener el recorrido de una lista y evitar caer en ciclos infinitos. Al igual que en  el caso de listas simplemente ligadas circulares, se suele utilizar un nodo de cabecera.

Este nodo tendrá las características descritas anteriormente y servirá como referencia para detectar cuando se ha recorrido totalmente la lista.

Hasta este momento se han estudiado las principales características de la estructura tipo lista, considerando todas sus variantes.

Código para listas circulares simplemente enlazadas

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct listacir{
 char nombre[40];
 struct listacir *siguiente;
};
struct listacir *primero=NULL, *ultimo=NULL;
int numNodos;
int pos;
void insertarUltimo ();
void insertarInicio ();
void insertarIntermedio ();
void visualizar();
void visualizarDesdePosicion();
void visualizarPrimeroUltimo();
void buscar();
void eliminar();
main(){
 int opcion;
 do{
  system("cls");
  printf("\n\n\n");
  printf("\n************************");
  printf("\n 1. Insertar Ultimo");
  printf("\n 2. Insertar Primero");
  printf("\n 3. Insertar en X posicion");
  printf("\n 4. Visualizar");
  printf("\n 5. Visualizar desde X posicion");
  printf("\n 6. Visualizar Primero y Ultimo");
  printf("\n 7. Buscar");
  printf("\n 8. Eliminar");
  printf("\n 9. Salir");
  printf("\n****************************");
  printf("\n\n\n");
  printf("\nElija una opcion  ");
  scanf("%d", &opcion);
  switch (opcion){
   case 1: insertarUltimo();
   break;
   case 2: insertarInicio();
   break;
   case 3: insertarIntermedio();
   break;
   case 4: visualizar();
   break;
   case 5: visualizarDesdePosicion();
   break;
   case 6: visualizarPrimeroUltimo();
   break;
   case 7: buscar();
   break;
   case 8: eliminar();
   break;
   case 9: printf("SALIR, GRACIAS POR ESTAR EN EL SISTEMA");
   break;
   default: system("cls");
   break;
  }
 }while (opcion!= 9);
}
void insertarUltimo(){
 system("cls");
 struct listacir *nuevo;
 nuevo=(struct listacir*)malloc(sizeof(struct listacir));
 if(nuevo==NULL)
 printf("\n Memoria insuficiente\n");
 else{
  printf("\n Nombre: ");
  fflush(stdin);
  gets(nuevo->nombre);
  nuevo->siguiente=primero;
  if(primero==NULL)
  {
   primero=nuevo;
   ultimo=nuevo;
  }else{
   ultimo->siguiente=nuevo;
   ultimo=nuevo;
  }
 }numNodos++;

}
void insertarInicio(){
 system("cls");
 struct listacir *nuevo;
 nuevo=(struct listacir*)malloc(sizeof(struct listacir));
 if(nuevo==NULL)
 printf("Memoria insuficiente\n");
 else{
  printf("\n Nombre: ");
  fflush(stdin);
  gets(nuevo->nombre);
  ultimo->siguiente = nuevo;
  nuevo->siguiente= primero;
  primero= nuevo;
  numNodos++;
 }
}
void insertarIntermedio(){
 system("cls");
 struct listacir *actual;
 struct listacir *nuevo;
 nuevo=(struct listacir*)malloc(sizeof(struct listacir));
 if (nuevo==NULL)
 printf("\nMemoria insuficiente");
 if(numNodos < 2)
 printf(" \n Numero de nodos insuficiente");
 else{
  int pos_insertar;
  printf("\n Nombre: ");
  fflush(stdin);
  gets(nuevo->nombre);
  printf("\nPosicion: ");
  scanf("%d", &pos_insertar);
  if((pos_insertar >1)&&(pos_insertar <= numNodos)){
 actual=primero;
 for(pos =2; pos <pos_insertar; ++pos)
 actual=actual->siguiente;
 nuevo->siguiente=actual->siguiente;
 actual->siguiente = nuevo;
 numNodos++;
 } }
 system("pause");
}
void visualizar(){
 system("cls");
 struct listacir *aux;
 pos=0;
 aux=primero;
 while(pos< numNodos){
  printf("%d.- ", pos+1);
  printf(" %s\n", aux->nombre);
  aux= aux->siguiente;
  pos++;
 }
 if(numNodos==0)
 printf("\nLista vacia");
 printf("\n\n\n\n\n");
 system("pause");
}
void visualizarPrimeroUltimo(){
 system("cls");
 if(numNodos==0)
 printf("\nLista vacia");
 else
 printf("\n Primero ------> %s", primero->nombre);
 printf("\n Ultimo--------_>%s", ultimo->nombre);
 printf("\n\n\n\n");
 system("pause");
 }
void visualizarDesdePosicion(){
 system("cls");
 int p=1;
 int posicion;
 struct listacir *actual;
 actual = primero;
  printf("\n Indique posicion  ");
  scanf("%d", &posicion);
  system("cls");
  for (pos = 2; pos <=posicion; pos++)
  {
   actual = actual->siguiente;
 }
 while (p <= numNodos)
  {
  printf("%s\n", actual->nombre);
  actual = actual->siguiente;
  p++;
  }
 printf("\n\n\n\n");
 system("pause");
}
void buscar() {
 system("cls");
 struct listacir *actual;
 char aux[40];
 int p =1;
 int encontrado=0;
 actual=primero;
 system("cls");
 printf("\n Indique nombre a buscar   ");
 fflush(stdin);
 gets(aux);system("cls");
 while (p <= numNodos)
 {
  if(strcmp(aux, actual->nombre)==0){
   printf("\n %s EXISTE", aux);
   encontrado =1;
   }
   p++;
   actual = actual->siguiente;
 }
 if (encontrado==0)
  printf("\n %s NO EXISTE", aux);
  printf("\n\n\n\n\n\n\n");
 system("pause");
 }

void eliminar(){
 system("cls");
 struct listacir *aux;
 struct listacir *anterior;
 pos=1;
 int nodo_eliminar;
 aux = primero;
 printf("\n Indique la posicion del nombre a eliminar ");
 scanf("%d", &nodo_eliminar);
 if(nodo_eliminar>numNodos || nodo_eliminar <1)
 printf("Elemento inexistente");
 else{
  if(nodo_eliminar==1)
  {
   aux=primero;
   primero = primero ->siguiente;
   free(aux);
   numNodos--;
  }
  else if(nodo_eliminar == numNodos)
  {
   while(pos<numNodos){
    if(pos==numNodos-1)
    anterior=aux;
    pos++;
    aux=aux->siguiente;
   
   }
if(pos==0)
printf("Lista vacia\n");
anterior->siguiente=primero;
ultimo=anterior;
free(aux);
numNodos--;  
 
  }
  else{
   while(pos<=numNodos){
   if(pos == nodo_eliminar-1)
   anterior=aux;
   if(pos == nodo_eliminar)
   free(aux);
   if(pos== nodo_eliminar + 1)
   anterior->siguiente=aux;
   pos++;
   aux = aux->siguiente;
  }
  numNodos--;
 }
 printf("\n\n\n\n\n");
 system("pause");
}
}

Apunte

Realice el siguiente apunte para el lunes en su cuaderno.

Listas circulares

 

Las listas circulares son similares a las listas simplemente ligadas. sin embargo, tienen las características de que el ultimo elemento de la lista apunta al primero, en lugar de apuntar al vacío o NIL(NULL).

 

Se define una lista simplemente ligada circular como una colección de elementos llamados nodos, el el cual el ultimo nodo apunta al primero.

 

Las operaciones en listas circulares son similares a las operaciones en listas lineales; por tanto, no se trataran nuevamente en esta sección. Sin embargo, es importante señalar que para el caso de la operación de recorrido de listas circulares se necesita considerar algún criterio para detectar cuando se han visitado todos los nodos de la lista.

Esto ultimo con el propósito de evitar caer en ciclos finitos. Una posible solución al problema planteado consiste en usar un nodo extra, llamado nodo de cabecera, para indicar el inicio de la lista. este nodo contendrá información especial, de tal manera que se distinga de los demás y así poder hacer referencia al principio de la lista.



Prácticas a realizar

1. Agenda:  En la agenda se deberá poder insertar nombre, dirección y teléfono, así como realizar todas las operaciones vistas durante las clases del tema listas doblemente enlazadas.

De la misma manera  serán las practicas siguientes.

2.   Inventario: Datos a insertar nombre del producto, cantidad en existencia, precio fecha de caducidad. Se deberá poder realizar todas las operaciones vistas.
3.   Registro de aspirantes: Datos a insertar nombre, apellidos, edad, carrera.Se deberá poder realizar todas las operaciones vistas.

Código para listas doblemente enlazadas

//Listas  doblemente enlazadas
//ITIC. Ana Francisca Martínez Betancourt
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct lista{
 char nombre[40];
 struct lista *siguiente;
 struct lista *anterior;
};
struct lista *primero=NULL, *ultimo=NULL;
int numNodos=0;
int posicion;
//Funciones o Prototipos
void insertarInicio();
void insertarFinal();
void buscar();
void eliminar();
void visualizarInicioFin();
void visualizarFinInicio();
void insertarIntermedio();
void visualizarXfinal();
void visualizarXinicio();
void visualizarPrimerUltimo();
main  (){
 int opcion;
 do{
  system("cls");
  printf("\n\n\n");
  printf("\n****************************************");
  printf("\n********Lista doblemente enlazada*******");
  printf("\n\n");
  printf("\n1. Insertar Datos al Inicio");
  printf("\n2. Insertar Datos al Final");
  printf("\n3. Insertar Datos en X posición");
  printf("\n4. Visualizar Lista de Inicio-Fin");
  printf("\n5. Visualizar Lista de Fin-Inicio");
  printf("\n6. Visualizar Lista de X dato al Inicio");
  printf("\n7. Visualizar Lista de X dato al Final");
  printf("\n8. Visualizar Primer y Ultimo Dato");
  printf("\n9. Buscar en Lista");
  printf("\n10. Eliminar en lista");
  printf("\n11. Salir");
  printf("\n****************************************");
  printf("\n\n");
  printf("Ingresar opcion");
  scanf("%d", &opcion);
  
   switch(opcion){
    case 1: insertarInicio();
    break;
    case 2:insertarFinal();
    break;
    case 3: insertarIntermedio();
    break;
    case 4: visualizarInicioFin();
    break;
    case 5: visualizarFinInicio();
    break;
    case 6: visualizarXinicio();
    break;
    case 7: visualizarXfinal();
    break;
    case 8: visualizarPrimerUltimo();
    break;
    case 9: buscar();
    break;
    case 10: eliminar();
    break;
    case 11: printf("Salir");
    break;
    default: system("cls");
    break;
   
   }
  }
   while (opcion !=11);  
}
void insertarFinal(){
 system("cls");
 struct lista *nuevo;
 nuevo=(struct lista*)malloc(sizeof(struct lista));
 if (nuevo == NULL)
 printf("\n Memoria insuficiente");
 else{
  printf("\n Nombre: ");
  fflush(stdin);
  gets(nuevo->nombre);
  nuevo->siguiente=NULL;
  if (primero==NULL){
  printf("\nNo hay primer dato");
  nuevo->anterior=NULL;
  nuevo->siguiente=NULL;
  primero=nuevo;
  ultimo=nuevo;}
  else {
   nuevo->siguiente=NULL;
   nuevo->anterior=ultimo;
   ultimo->siguiente=nuevo;
   ultimo=nuevo;
  }

 }numNodos++;}
void insertarInicio(){
 system("cls");
 struct lista *nuevo;
 nuevo=(struct lista*)malloc(sizeof(struct lista));
 if (nuevo == NULL)
 printf("\n Memoria insuficiente");
 else{
  printf("\n Nombre: ");
  fflush(stdin);
  gets(nuevo->nombre);
  nuevo->anterior=NULL;
 if(ultimo==NULL){
  nuevo->siguiente=NULL;
  nuevo->anterior=NULL;
  primero=nuevo;
  ultimo=nuevo;
  }
  else{
  nuevo->anterior=NULL;
  nuevo->siguiente=primero;
  primero->anterior=nuevo;
  primero=nuevo; }}
  numNodos++;
 }


 void visualizarInicioFin() {
  system("cls");
  struct lista *actual;
  posicion=1;
  actual=primero;
  while(posicion<=numNodos){
   printf(" %d.- ", posicion);
   printf("%s\n",actual->nombre);
   actual=actual->siguiente;
   posicion++;
  }
  if(numNodos==0)
  printf("\nLista vacia");
  printf("\n\n\n");
  system("pause");
  }
 void insertarIntermedio (){
 system ("cls");
 struct lista *actual, *nuevo;
 nuevo=( struct lista*)malloc(sizeof( struct lista));
 if (nuevo==NULL)
 printf("\n MEMORIA INSUFUCIENTE\n");
 if (numNodos <2)
 printf ("\n Número de nodos insuficiente");
 else{
  int pos_insertar;
  printf("\n Nombre:   ");
  fflush(stdin);
  gets(nuevo->nombre);
  printf ("\n Posicion:  ");
  scanf ("%d", &pos_insertar);
  if((pos_insertar >1) &&(pos_insertar <= numNodos)){
   actual=primero;
   for (posicion = 2; posicion <pos_insertar; ++posicion)
   actual= actual->siguiente;
   nuevo->siguiente= actual->siguiente;
   nuevo->anterior = actual;
   actual->siguiente->anterior = nuevo;
   actual->siguiente = nuevo;
   numNodos++;
  }
 }
 printf("\n\n\n\n\n\n\n");
 system("pause");
}
 void visualizarFinInicio(){
 system("cls");
 struct lista *actual;
 actual=ultimo;
 posicion= numNodos;
 while (posicion >0){
  printf(" %d.- ", posicion);
  printf("%s\n",actual->nombre);
  actual =actual->anterior;
  posicion--;
 }
 if(numNodos==0)
 printf("\n LISTA VACIA");
 printf("\n\n\n\n\n\n\n");
 system("pause");
 }
 void visualizarXfinal(){
  system("cls");
 int pos;
 struct lista *actual;
 actual = primero;
 printf("\n Indique posicion     ");
 scanf("%d", &pos);
 system("cls");
 for (posicion = 2; posicion<=pos; posicion++){
  actual = actual->siguiente;
 }
 while (pos <= numNodos){
  printf("%d.-", pos);
  printf("%s\n", actual->nombre);
  actual = actual->siguiente;
  pos++;
 }
 printf("\n\n\n\n\n\n\n");
 system("pause");
 }
 void visualizarXinicio(){
    system("cls");
   int pos;
   struct lista *actual;
    actual = primero;
    printf ("\n Indique posicion   ");
    scanf("%d",&pos);
   system ("cls");
   for (posicion = 2; posicion <=pos; posicion++){
    actual  = actual->siguiente;
 }

   posicion = pos;
 while (actual!= NULL){
  printf(" %d.- ", posicion);
  printf("%s\n", actual->nombre);
  actual = actual->anterior;
  posicion--;
 }
 printf("\n\n\n\n\n\n\n");
 system("pause");
}
 void visualizarPrimerUltimo(){
  system("cls");
 if(numNodos==0)
  printf("\n LISTA VACIA");
 else
  printf("\n PRIMERO -------> %s", primero->nombre);
  printf("\n\n ULTIMO  ------>%s", ultimo->nombre);
  printf("\n\n\n\n\n\n\n");
   system ("pause");
}
 void buscar(){
  system("cls");
 struct lista *actual;
 char aux [40];
 int p = 1;
 int encontrado =0;
 actual = primero;
 system("cls");
 printf("\n Indique nombre a buscar  ");
 fflush(stdin);
 gets(aux);
 system("cls");
 while (p <= numNodos){
  if(strcmp(aux, actual->nombre)==0){
   printf("\n %s EXISTE", aux);
   encontrado =1;
   }
   p++;
   actual = actual->siguiente;
 }
 if (encontrado==0)
  printf("\n %s NO EXISTE", aux);
  printf("\n\n\n\n\n\n\n");
 system("pause");
 }
void eliminar(){
 system("cls");
 struct lista *aux;
 struct lista *actual;
 int nodo_eliminar;
 int x;
 printf("\n Indique la posicion del nombre a eliminar ");
 scanf(" %d", &nodo_eliminar);
 if (nodo_eliminar > numNodos || nodo_eliminar < 1)
 printf("Elemento inexistente");
 if (nodo_eliminar == 1){
  aux = primero;
  primero = primero->siguiente;
  if (primero == NULL)
  ultimo = NULL;
  else
  primero ->anterior == NULL;
   }
   else if (nodo_eliminar == numNodos){
    aux = ultimo;
    ultimo->anterior->siguiente = NULL;
    ultimo = ultimo->anterior;
   }else{
    actual = primero;
    for (x=1; x<nodo_eliminar; ++x)
    actual = actual->siguiente;
    aux = actual;
    actual->anterior->siguiente = actual->siguiente;
    actual->siguiente->anterior = actual->anterior;
   }
free(aux);
numNodos--;
 }

LISTAS SIMPLEMENTE ENLAZADAS CON OPERACIONES

//ITIC. ANA FRANCISCA MARTÍNEZ BETANCOURT
//LISTAS SIMPLEMENTE ENLAZADAS
//ESTRUCTURAS DE DATOS II
#include <iostream>
#include <stdlib.h>
using namespace std;

struct nodo{
       int nro;        // en este caso es un numero entero
       struct nodo *sgte;
};

typedef struct nodo *Tlista;

void insertarInicio(Tlista &lista, int valor)
{
    Tlista q;
    q = new(struct nodo);
    q->nro = valor;
    q->sgte = lista;
    lista  = q;
}

void insertarFinal(Tlista &lista, int valor)
{
    Tlista t, q = new(struct nodo);

    q->nro  = valor;
    q->sgte = NULL;

    if(lista==NULL)
    {
        lista = q;
    }
    else
    {
        t = lista;
        while(t->sgte!=NULL)
        {
            t = t->sgte;
        }
        t->sgte = q;
    }

}

int insertarAntesDespues()
{
    int _op, band;
    cout<<endl;
    cout<<"\t 1. Antes de la posicion           "<<endl;
    cout<<"\t 2. Despues de la posicion         "<<endl;

    cout<<"\n\t Opcion : "; cin>> _op;

    if(_op==1)
        band = -1;
    else
        band = 0;

    return band;
}

void insertarElemento(Tlista &lista, int valor, int pos)
{
    Tlista q, t;
    int i;
    q = new(struct nodo);
    q->nro = valor;

    if(pos==1)
    {
        q->sgte = lista;
        lista = q;
    }
    else
    {
        int x = insertarAntesDespues();
        t = lista;

        for(i=1; t!=NULL; i++)
        {
            if(i==pos+x)
            {
                q->sgte = t->sgte;
                t->sgte = q;
                return;
            }
            t = t->sgte;
        }
    }
    cout<<"   Error...Posicion no encontrada..!"<<endl;
}

void buscarElemento(Tlista lista, int valor)
{
    Tlista q = lista;
    int i = 1, band = 0;

    while(q!=NULL)
    {
        if(q->nro==valor)
        {
            cout<<endl<<" Encontrada en posicion "<< i <<endl;
            band = 1;
        }
        q = q->sgte;
        i++;
    }

    if(band==0)
        cout<<"\n\n Numero no encontrado..!"<< endl;
}

void reportarLista(Tlista lista)
{
     int i = 0;

     while(lista != NULL)
     {
          cout <<' '<< i+1 <<") " << lista->nro << endl;
          lista = lista->sgte;
          i++;
     }
}


void eliminarElemento(Tlista &lista, int valor)
{
    Tlista p, ant;
    p = lista;

    if(lista!=NULL)
    {
        while(p!=NULL)
        {
            if(p->nro==valor)
            {
                if(p==lista)
                    lista = lista->sgte;
                else
                    ant->sgte = p->sgte;

                delete(p);
                return;
            }
            ant = p;
            p = p->sgte;
        }
    }
    else
        cout<<" Lista vacia..!";
}

void eliminaRepetidos(Tlista &lista, int valor)
{
    Tlista q, ant;
    q = lista;
    ant = lista;

    while(q!=NULL)
    {
        if(q->nro==valor)
        {
            if(q==lista) // primero elemento
            {
                lista = lista->sgte;
                delete(q);
                q = lista;
            }
            else
            {
                ant->sgte = q->sgte;
                delete(q);
                q = ant->sgte;
            }
        }
        else
        {
            ant = q;
            q = q->sgte;
        }

    }// fin del while
 
    cout<<"\n\n Valores eliminados..!"<<endl;
}

void menu1()
{
    cout<<"\n\t\tLISTA ENLAZADA SIMPLE\n\n";
    cout<<" 1. INSERTAR AL INICIO               "<<endl;
    cout<<" 2. INSERTAR AL FINAL                "<<endl;
    cout<<" 3. INSERTAR EN UNA POSICION         "<<endl;
    cout<<" 4. REPORTAR LISTA                   "<<endl;
    cout<<" 5. BUSCAR ELEMENTO                  "<<endl;
    cout<<" 6. ELIMINAR ELEMENTO 'V'            "<<endl;
    cout<<" 7. ELIMINAR ELEMENTOS CON VALOR 'V' "<<endl;
    cout<<" 8. SALIR                            "<<endl;

    cout<<"\n INGRESE OPCION: ";
}


/*                        Funcion Principal
---------------------------------------------------------------------*/

int main()
{
    Tlista lista = NULL;
    int op;     // opcion del menu
    int _dato;  // elemenento a ingresar
    int pos;    // posicion a insertar


    system("color 0b");

    do
    {
        menu1();  cin>> op;

        switch(op)
        {
            case 1:

                 cout<< "\n NUMERO A INSERTAR: "; cin>> _dato;
                 insertarInicio(lista, _dato);
            break;


            case 2:

                 cout<< "\n NUMERO A INSERTAR: "; cin>> _dato;
                 insertarFinal(lista, _dato );
            break;


            case 3:

                 cout<< "\n NUMERO A INSERTAR: ";cin>> _dato;
                 cout<< " Posicion : ";       cin>> pos;
                 insertarElemento(lista, _dato, pos);
            break;


            case 4:

                 cout << "\n\n MOSTRANDO LISTA\n\n";
                 reportarLista(lista);
            break;


            case 5:

                 cout<<"\n Valor a buscar: "; cin>> _dato;
                 buscarElemento(lista, _dato);
            break;

            case 6:

                cout<<"\n Valor a eliminar: "; cin>> _dato;

                eliminarElemento(lista, _dato);
            break;

            case 7:

                cout<<"\n Valor repetido a eliminar: "; cin>> _dato;

                eliminaRepetidos(lista, _dato);
            break;

                    }

        cout<<endl<<endl;
        system("pause");  system("cls");

    }while(op!=8);


   system("pause");
   return 0;
}

Código

#include <iostream>
#include <stdlib.h>
using namespace std;

struct nodo{
       int numero;        // en este caso es un numero entero
       struct nodo *sgte;
};

typedef struct nodo *Tlista;

void insertarInicio(Tlista &lista, int valor)
{
    Tlista q;
    q = new(struct nodo);
    q->numero = valor;
    q->sgte = lista;
    lista  = q;
}
void reportarLista(Tlista lista)
{
     int i = 0;

     while(lista != NULL)
     {
          cout <<' '<< i+1 <<") " << lista->numero << endl;
          lista = lista->sgte;
          i++;
     }
}
void menu1()
{
    cout<<"\n\t\tLISTA ENLAZADA SIMPLE\n\n";
    cout<<" 1. INSERTAR AL INICIO               "<<endl;
    cout<<" 2. REPORTAR LISTA                   "<<endl;
    cout<<" 3. SALIR                            "<<endl;

    cout<<"\n INGRESE OPCION: ";
}

/*                        Funcion Principal
---------------------------------------------------------------------*/

int main()
{
    Tlista lista = NULL;
    int op;     // opcion del menu
    int _dato;  // elemenento a ingresar
    int pos;    // posicion a insertar


    system("color 0b");

    do
    {
        menu1();  cin>> op;

        switch(op)
        {
            case 1:

                 cout<< "\n NUMERO A INSERTAR: "; cin>> _dato;
                 insertarInicio(lista, _dato);
            break;

          case 2:
          cout << "\n\n MOSTRANDO LISTA\n\n";
                 reportarLista(lista);
            break;


                    }

        cout<<endl<<endl;
        system("pause");  system("cls");

    }while(op!=3);


   system("pause");
   return 0;
}