Foro de elhacker.net

Programación => Programación C/C++ => Mensaje iniciado por: ANTÓN RAMIREZ en 14 Diciembre 2010, 21:10 pm


Título: operaciones basicas con listas Simples y Dobles....
Publicado por: ANTÓN RAMIREZ en 14 Diciembre 2010, 21:10 pm
A continuación se presentan los algoritmos de operaciones con listas. La estructura es:
Para todas las acciones, Cab es un apuntador al primer nodo de la lista
Utilizaremos una notación para usarla en nuestros algoritmos de tal modo que estas sean independientes de cualquier lenguaje de programación.
Si P es un apuntador (puntero) del tipo NODO entonces P.Val hace referencia a la parte valor (información) del nodo apuntado por P de la misma manera P.Sgte hace referencia a la parte dirección siguiente del nodo apuntado por P..
En esta oportunidad implemento una lista dinamica, pero queda de antemano que existe la implementacion de lista estatica , osea usando vectores , haber si alguien lo obtine por alli , o mas aplicaciones de listes simples , hay tambien listas dobles y logicamente la lista circular , en esta oportunidad les dejo operaciones de listas simples.


ATTE : ANTON RAMIREZ , LEONARDO VLADIMIR  (ALUMNO UNI)

 Crea una lista enlazada de simple anadiendo nodos de numeros pares al final de la lista.

Código
  1. [li]// Aqui NODO debe ser global porque pude declararse en cualquier parte del programa
  2. struct NODO
  3. {
  4.  int Val;
  5.  NODO *Sgte;
  6. };
  7.  
  8. //Crea una lista vacia
  9. void CrearLista (NODO **Cab, NODO **Final);
  10.  
  11. // Crea una Lista de numeros Pares anadiendo al final de la lista
  12. void CrearLPares(NODO **Cab, NODO **Final);
  13.  
  14. // Muestra la Lista
  15. void MostrarLPares(NODO *Cab);
  16.  
  17. // Predicado que devuelve verdad si X es Par y falso en otro caso
  18. bool VrfcaPar(int x);
  19.  
  20. // Funcion principal
  21. int main()
  22. {
  23.  NODO *L1; // Apuntador de tipo NODO para apuntar al primer elemento de la lista
  24.  NODO *U1; // Apuntador de tipo NODO para apuntar al ultimo elemento de la lista
  25.  //Creamos la lista L1 vacia
  26.  CrearLista(&L1, &U1);
  27.  // Llenamos la lista L1 con elementos pares
  28.  CrearLPares(&L1, &U1);
  29.  //Mostramos la lista L1 de pares
  30.  MostrarLPares(L1);
  31.  
  32.  system("PAUSE");
  33.  return(0);
  34. }
  35.  
  36. void CrearLista (NODO **Cab, NODO **Final)
  37. {
  38.  *Cab=NULL;
  39.  *Final=NULL; 
  40. }
  41.  
  42. void CrearLPares(NODO **Cab, NODO **Final)
  43. {
  44.  int Num, Ctdor, i;
  45.  NODO *P;
  46.  Ctdor = 0; i = 1;
  47.  //system("CLS");
  48.  cout <<"Cuanto numeros pares desea ingresar " ;
  49.  cin >>Num;
  50.  while(Ctdor < Num)
  51.  {
  52.  if(VrfcaPar(i))
  53.  {
  54.  cout<<"Elemento ---> "<<i<<endl;
  55.  //P = new NODO; // Que pasa si no hay memoria suficiente ?
  56.  P = (NODO*)malloc(sizeof(NODO)); // Que pasa si no hay memoria suficiente ?
  57.  if(*Cab == NULL)
  58.  {
  59.  P->Val = i;
  60.  P->Sgte=NULL;
  61.  *Cab = P;
  62.  *Final =P;
  63.  }
  64.  else
  65.  {
  66.  P->Val = i;
  67.  P->Sgte=NULL;
  68.  (*Final)->Sgte = P;
  69.  }
  70.  *Final = P;
  71.  //(*Final)->Sgte = NULL;
  72.  Ctdor = Ctdor + 1;
  73.  }
  74.  i = i + 1;
  75.  }
  76.  system("PAUSE");
  77. }
  78.  
  79.  
  80. bool VrfcaPar(int x)
  81. {
  82.  if(x%2 == 0)
  83.  {
  84.  return(true);
  85.  }
  86.  else
  87.  {
  88.  return(false);
  89.  }
  90.  
  91. }
  92.  
  93. void MostrarLPares(NODO *Cab)
  94. {
  95.  //system("CLS");
  96.  // Utilizamos una variable auxiliar para desplazarnos en la lista
  97.  NODO *P;
  98.  printf("\nlista = < ");
  99.  P = Cab;
  100.  while(P != NULL)
  101.  {
  102.  cout<<P->Val<<" ";
  103.  P = P->Sgte;
  104.  }
  105.  cout<<">"<<endl;
  106.  system("PAUSE");
  107. }[/color][/li]
  108. [li][/li]
  109. [/list]

Código:
// Listas Dobles
using namespace std;

typedef int TD;// crea un sinomino de int

struct NODO
{
 TD val;
 NODO *ante; 
 NODO *sgte;
};
void crearLista(NODO **Cabi, NODO **Cabu);// doble apúntador porque *cab es apuntador 
void insertarIni(NODO **Cabi,NODO **Cabu, TD dato);
void mostrarNodos(NODO *Cabi);

int main()
{
 NODO *ai, *au;
 crearLista(&ai, &au);

 insertarIni(&ai,&au, 10); 
 insertarIni(&ai,&au, 20); 
 insertarIni(&ai,&au, 30); 

 mostrarNodos(ai); 
 
 
 cout <<("\n\n");
 system("pause");
 return(0);
} 
 
void crearLista(NODO **Cabi, NODO **Cabu)// doble apúntador porque *cab es apuntador 
{
 *Cabi=NULL;
 *Cabu=NULL;
 
} 
 
void insertarIni(NODO **Cabi,NODO **Cabu, TD dato)
{
 NODO * p;
 
 p=(NODO*)malloc(sizeof(NODO));//MALLOC DEVUELVE LA VARIABLE NO A VOID SINO A NODO
 
 if(p==NULL){// hubo exito en la separacion de memoria
 printf("nO HAY espacio en la RAM");
 exit(0);
 }
 else{
 p->val=dato;
 p->ante=NULL;
 p->sgte=NULL;
 if(*Cabi==NULL){
 *Cabi=p;
 *Cabu=p;
 }
 else{
 p->sgte=*Cabi;
 (*Cabi)->ante=p;//ya que el * y -> tienen la misma prioridad.
 *Cabi=p;
 }
 }
}
void mostrarNodos(NODO *Cabi)
{
 NODO *p;
 p=Cabi;
 while(p!=NULL){//si pusiera p->sgte!=NULL no mostraria al 10 yaq psgte no existe 
 cout << p->val<<",";
 p=p->sgte; 
 }
} [/code=c]


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines