Foros del Web » Programación para mayores de 30 ;) » C/C++ »

Guia_Listas_Enlazadas - C++

 Estas en el tema de Guia_Listas_Enlazadas - C++ en el foro de C/C++ en Foros del Web. Saludos!! El presente tema tiene como finalidad resolver una guía de programación estructurada en C++. Este es el código con el que se va a ...
  #1 (permalink)  
Antiguo 19/07/2013, 15:41
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Pregunta Guia_Listas_Enlazadas - C++
Saludos!!

El presente tema tiene como finalidad resolver una guía de programación estructurada en C++.

Este es el código con el que se va a trabajar.

Código C++: 
Ver original
  1. // Agrega_Clase_ListaSE.cpp: archivo de proyecto principal.
  2.  
  3. #include "stdafx.h"
  4. #include "iostream"
  5. using namespace System;
  6. using namespace std;
  7. struct nodo 
  8. {
  9.     int dato;
  10.     nodo *sig;
  11. };
  12. class Lse 
  13. {
  14. private:
  15.     nodo *inicial;
  16.     nodo *buscarLista(int clave); 
  17. public:
  18.     Lse();
  19.     ~Lse();
  20.     void agregar();
  21.     void eliminar();
  22.     void desplegarLista();
  23. };
  24. Lse::Lse()
  25. {
  26.     inicial=NULL;
  27. }
  28. Lse::~Lse ()
  29. {
  30. }
  31. void Lse::desplegarLista()
  32. {
  33.     if(inicial==NULL)
  34.     {
  35.         cout<<"La lista esta vacia"<<endl;
  36.     }
  37.     else
  38.     {
  39.         nodo *apunt;
  40.         apunt=inicial;
  41.         while(apunt!=NULL)
  42.         {
  43.             cout<<apunt->dato<<endl;
  44.             apunt=apunt->sig;
  45.         }
  46.     }   
  47. }
  48. nodo *Lse::buscarLista(int clave)
  49. {
  50.     //Devuelve la dirección del nodo que antecede al nuevo //nodo que va a ser agregado, o que va a ser eliminado.
  51.     //Si la clave es menor o igual al dato del primer nodo //el valor devuelto es NULL.
  52.     //Si la clave es mayor que el dato del último nodo //devuelve la dirección del último nodo.
  53.  
  54.     nodo *anterior;
  55.     anterior=NULL;
  56.     if(clave <= inicial->dato)return anterior;
  57.     else
  58.     {
  59.         anterior=inicial;
  60.         while ( ( anterior->sig!=NULL) && (clave > anterior->sig->dato) )
  61.                                                   anterior=anterior->sig; 
  62.         return anterior;
  63.     }
  64. }
  65. void Lse::agregar()
  66. {
  67.     nodo *nuevo,*anterior; 
  68.     char resp;
  69.     do 
  70.     {
  71.         nuevo=new nodo();
  72.         cout<<"Entre clave del nodo a agregar"<<endl;
  73.         cin>>nuevo->dato;
  74.         if(inicial==NULL)
  75.         {
  76.             //Agrega el primer nodo a la lista 
  77.             inicial=nuevo; 
  78.             nuevo->sig=NULL;
  79.         }
  80.         else
  81.         {
  82.             //Agrega a una lista que contiene al menos un nodo
  83.             anterior=buscarLista(nuevo->dato); 
  84.             if(anterior==NULL)
  85.             {
  86.                 //Agrega un nodo que queda de primero 
  87.                 //en una lista que no estaba vacia
  88.                 nuevo->sig=inicial; 
  89.                 inicial=nuevo;
  90.             }
  91.             else
  92.             {
  93.                 if(anterior->sig!=NULL)
  94.                 {
  95.                     //Agrega un nodo que queda entre el 
  96.                     //primero y el ultimo
  97.                     nuevo->sig=anterior->sig;
  98.                     anterior->sig=nuevo;
  99.                 }
  100.                 else
  101.                 {
  102.                     //Agrega un nodo que queda de ultimo 
  103.                     nuevo->sig=NULL; 
  104.                     anterior->sig=nuevo;
  105.                 }
  106.             }
  107.         }
  108.         cout<<"Desea agregar otro nodo? (s/n)"<<endl; 
  109.         cin>>resp; 
  110.         resp=tolower(resp);
  111.     }while(resp=='s');
  112. }
  113. void main()
  114. {
  115.     Lse l;
  116.     l.agregar();
  117.     l.desplegarLista();
  118. }

Bien, acontinuación imagenes de la guía:





En Flirck:
1. http://farm3.staticflickr.com/2862/9...e64f8d0a_o.jpg
2. http://farm4.staticflickr.com/3710/9...6d0854ba_o.jpg
3. http://farm3.staticflickr.com/2819/9...8e45637c_o.jpg


Podrán encontrar la guía completa en PDF aquí: " https://mega.co.nz/#!aB1DRDiC!RWu4s1...lGa3yAev7cTsso
"

Ahora bien. Mi duda actual se refiere a la interpretación de las lineas:

Código C++: 
Ver original
  1. nodo *Lse::buscarLista(int clave)
  2. {
  3.     //Devuelve la dirección del nodo que antecede al nuevo //nodo que va a ser agregado, o que va a ser eliminado.
  4.     //Si la clave es menor o igual al dato del primer nodo //el valor devuelto es NULL.
  5.     //Si la clave es mayor que el dato del último nodo //devuelve la dirección del último nodo.
  6.  
  7.     nodo *anterior;
  8.     anterior=NULL;
  9.     if(clave <= inicial->dato)return anterior;
  10.     else
  11.     {
  12.         anterior=inicial;
  13.         while ( ( anterior->sig!=NULL) && (clave > anterior->sig->dato) )
  14.                                                   anterior=anterior->sig; 
  15.         return anterior;
  16.     }
  17. }

¿Qué está haciendo el programa?, ¿Asignando el código de memoria de un nodo-dato a otro?, ¿Cómo funciona el mecanismo?, ¿Cuándo intermabio el código de memoria ( En este caso x4 -> x9) ?, ¿Qué significa el simbolo "->"?

Gracias de antemano por la ayuda.
  #2 (permalink)  
Antiguo 21/07/2013, 05:58
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
"...¿Qué está haciendo el programa?..."

Pon puntos de depuracion y observa las variables


"...¿Asignando el código de memoria de un nodo-dato a otro?..."

Lo que hace es recorrer los nodos, simplemente está reasignando punteros: 'anterior' es un puntero, se le asigna el puntero 'inicial' (es otro puntero que apunta a la direccion de memoria con la que se inicializó la lista), y se va reasignando con el puntero al elemento 'siguiente' para recorrer la lista; observa que si resignaras sobre el elemento 'inicial' obtendrias que al final 'inicial' sería el ultimo elemento y no habría forma de reiniciar (sin un auxiliar inicial y sin punteros internos al inicio)


"...¿Qué significa el simbolo "->"?..."

Revisa tus apuntes. Cambia 'anterior->sig' por 'anterior.sig' y observa que te dice el compilador

Saludos
vosk
  #3 (permalink)  
Antiguo 21/07/2013, 08:09
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Pregunta Respuesta: Guia_Listas_Enlazadas - C++
Gracias por tu ayuda, me gustaría saber si voy por buen camino:

La duda es la siguiente, ¿Cuál de las dos direcciones de memoria posibles sería la correcta?



Flirck: http://farm8.staticflickr.com/7311/9...27e20af4_o.jpg

Gracias de antemano!!
  #4 (permalink)  
Antiguo 21/07/2013, 08:33
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
Una cosa son las posiciones en la lista, otra cosa son las posiciones de memoria: si 10 se guarda en x4, 5 se guarda en la siguiente disponible (x4 ya está ocupado) porque se trata por igual 5 que 5000, no infuye el echo de ser ordinal menor

Oye una cosa, los deberes no tendrias que hacerlos tu solo?

Saludos
vosk
  #5 (permalink)  
Antiguo 21/07/2013, 09:18
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Respuesta: Guia_Listas_Enlazadas - C++
Sip los deberes los tengo que hacer. Pero nadie dijo que sólo. Hago mi mejor esfuerzo y no tengo ni idea de cómo programar en C++. Estoy aprendiendo. Agradecería que me siguieras ayudando...¿Es posible?
  #6 (permalink)  
Antiguo 21/07/2013, 09:52
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
Si claro que es posible, te puedo ayudar yo (dentro de lo poco que se) y supongo que tambien cualquiera que esté en el foro (incluso mas y mejor).


"...Pero nadie dijo que sólo..."

Ok, pero si para preguntar cuelgas un scan de los deberes la gente mira para otro lado (supongo que todos tenemos suficiente trabajo como para hacer el de otro). Seguramente el moderador del foro podrá orientarte acerca de como plantear temas de forma clara, concisa y amigable para que el mayor numero de gente tenga ganas de ayudarte.

Saludos
vosk
  #7 (permalink)  
Antiguo 22/07/2013, 21:08
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Sonrisa Respuesta: Guia_Listas_Enlazadas - C++
Gracias por tu ayuda. Después de varias horas de arduo análisis quiero compartir mis avances contigo :D

Código C++: 
Ver original
  1. // Introduce 10
  2. +       inicial 0x00000000                  nodo*
  3. +       nuevo   0x00400AC8 //x4 { dato=10 sig=0x00000000 }  nodo*
  4.         nuevo->dato           10 int
  5. // Ingresa a if(inicial==NULL)
  6. +       inicial 0x00400AC8 //x4 { dato=10 sig=0x00000000 }  nodo*
  7. +       nuevo   0x00400AC8 //x4 { dato=10 sig=0x00000000 }  nodo*
  8. +       nuevo->sig  0x00000000  nodo*
  9. // Sale
  10.  
  11. //Introduce 20
  12.         anterior            <valor no definido> nodo*
  13. +       nuevo   0x004664C8 //x9 { dato=20 sig=0x00000000 }  nodo*
  14.         nuevo->dato            20 int
  15.  
  16. // Ingreso a: "anterior=buscarLista(nuevo->dato);"
  17.  
  18. // anterior==NULL; // anterior auxiliar
  19.  
  20.         anterior            <valor no definido> nodo*
  21.         clave                       20  int
  22. +       inicial 0x00400AC8 //x4{ dato=10 sig=0x00000000 }   nodo*
  23.         inicial->dato   10  int
  24.  
  25. // anterior=inicial;
  26.  
  27. +       anterior 0x00400AC8 //x4{ dato=10 sig=0x00000000 }  nodo*
  28. +       anterior->sig   0x00000000  nodo*
  29.         clave                       20  int
  30. +       inicial  0x00400AC8 //x4{ dato=10 sig=0x00000000 }  nodo*
  31.  
  32. // return anterior;
  33.  
  34. +       anterior 0x00400AC8 //x4{ dato=10 sig=0x00000000 }  nodo*
  35. +       anterior->sig               0x00000000  nodo*
  36.  
  37. // nuevo->sig=NULL; //Agrega un nodo que queda de ultimo 
  38.  
  39. +       nuevo   0x004664C8 //x9{ dato=20 sig=0x00000000 }   nodo*
  40. +       nuevo->sig  0x00000000  nodo*
  41.  
  42. //Introduce 30
  43. +       anterior    0x00400AC8 //x4  { dato=10 sig=0x004664C8} nodo*
  44. +       nuevo       0x003F50D0 //x12 { dato=30 sig=0x00000000} nodo*
  45.         nuevo->dato 30  int
  46.  
  47.  
  48. // Buscarlista
  49. +       anterior    0x00400AC8 //x4 { dato=10 sig=0x004664C8 }  nodo*
  50. +       anterior->sig   0x004664C8 //x9 { dato=20 sig=0x00000000 }  nodo*
  51.         anterior->sig->dato 20  int
  52.         clave           30  int
  53. +       inicial     0x00400AC8 //x4 { dato=10 sig=0x004664C8 }  nodo*
  54.  
  55. // Entra 1ra ves While;
  56.  
  57. +       anterior    0x004664C8 //x9 { dato=20 sig=0x00000000 }  nodo*
  58. +       anterior->sig   0x00000000  nodo*
  59.         clave   30  int
  60. +       inicial 0x00400AC8 //x4{ dato=10 sig=0x004664C8 }       nodo*
  61.  
  62.  
  63. // Retorna "anterior;
  64.  
  65. +       anterior    0x004664C8 //x9 { dato=20 sig=0x00000000 }  nodo*
  66. +       anterior->sig   0x00000000  nodo*
  67.  
  68. // anterior=buscarLista(nuevo->dato);
  69.  
  70. +       anterior    0x00400AC8 //x9 { dato=10 sig=0x004664C8 }  nodo*
  71. +       nuevo       0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  72.         nuevo->dato 30  int
  73.  
  74. // if(anterior->sig!=NULL)
  75.  
  76. +       anterior    0x004664C8 //x9 { dato=20 sig=0x00000000 }  nodo*
  77. +       anterior->sig   0x00000000  nodo*
  78.  
  79. //Agrega un nodo que queda de ultimo
  80. // nuevo->sig=NULL; 
  81.  
  82. +       nuevo       0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  83. +       nuevo->sig  0x00000000                  nodo*
  84.  
  85. // anterior->sig=nuevo;
  86. +       anterior    0x004664C8 //x9 { dato=20 sig=0x00000000 }  nodo*
  87. +       anterior->sig   0x00000000                  nodo*
  88. +       nuevo       0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  89. +       nuevo->sig  0x00000000                  nodo*
  90.  
  91.  
  92. // Introduce 5
  93.  
  94. +       inicial     0x00400AC8 //x4 { dato=10 sig=0x004664C8 }  nodo*
  95. +       nuevo       0x004663D8 //x24{ dato=5 sig=0x00000000 }   nodo*
  96.         nuevo->dato 5   int
  97. // funcion buscar();
  98.  
  99.         anterior    <valor no definido> nodo*
  100.         clave   5   int
  101. +       inicial     0x00400AC8 //x4 { dato=10 sig=0x004664C8 }  nodo*
  102.         inicial->dato   10  int
  103.  
  104. // return "anterior";
  105.  
  106. +       anterior    0x004664C8 //x9  { dato=20 sig=0x003F50D0 } nodo*
  107. +       nuevo       0x004663D8 //x24 { dato=5 sig=0x00000000 }  nodo*
  108.         nuevo->dato 5   int
  109.  
  110. // if( anterior==NULL)
  111. //nuevo->sig=inicial;
  112.  
  113.  
  114. +       inicial     0x00400AC8 //x4 { dato=10 sig=0x004664C8 }  nodo*
  115. +       nuevo       0x004663D8 //x24{ dato=5 sig=0x00000000 }   nodo*
  116. +       nuevo->sig  0x00000000  nodo*
  117.  
  118.  
  119. // inicial=nuevo;
  120.  
  121. +       inicial     0x004663D8 //x24 { dato=5 sig=0x00400AC8 }  nodo*
  122. +       nuevo       0x004663D8 //x24 { dato=5 sig=0x00400AC8 }  nodo*
  123. +       nuevo->sig  0x00400AC8 //x4  { dato=10 sig=0x004664C8 } nodo*
  124.  
  125. // Funcion buscarlista();
  126.  
  127.         anterior    <valor no definido> nodo*
  128. +       nuevo   0x00466420 { dato=25 sig=0x00000000 }   nodo*
  129.         nuevo->dato 25  int
  130.  
  131. // Ingreso al while de buscarlista();
  132.  
  133. +       anterior    0x004663D8 //x24 { dato=5 sig=0x00400AC8 }  nodo*
  134. +       anterior->sig   0x00400AC8 //x4  { dato=10 sig=0x004664C8 } nodo*
  135.         anterior->sig->dato 10  int
  136.         clave           25  int
  137. +       inicial     0x004663D8 //x24 { dato=5 sig=0x00400AC8 }  nodo*
  138.  
  139.  
  140. // Segundo acceso a while;
  141. +       anterior    0x00400AC8 //x4 { dato=10 sig=0x004664C8 }  nodo*
  142. +       anterior->sig   0x004664C8 //x9 { dato=20 sig=0x003F50D0 }  nodo*
  143.         anterior->sig->dato 20  int
  144.         clave           25  int
  145. +       inicial     0x004663D8 //x24{ dato=5 sig=0x00400AC8 }   nodo*
  146.  
  147.  
  148.  
  149. // Tercer acceso a while;
  150. +       anterior    0x004664C8 //x9 { dato=20 sig=0x003F50D0 }  nodo*
  151. +       anterior->sig   0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  152.         anterior->sig->dato 30  int
  153.         clave   25  int
  154. +       inicial     0x004663D8 //x24{ dato=5 sig=0x00400AC8 }   nodo*
  155.  
  156.  
  157.  
  158. // Finalización del while;
  159. +       anterior    0x004664C8 //x9 { dato=20 sig=0x003F50D0 }  nodo*
  160. +       nuevo       0x00466420 //x36{ dato=25 sig=0x00000000 }  nodo*
  161.  
  162. //if(anterior->sig!=NULL)
  163. +       anterior    0x004664C8 //x9 { dato=20 sig=0x003F50D0 }  nodo*
  164. +       anterior->sig   0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  165.  
  166. // nuevo->sig=anterior->sig;
  167.  
  168. +       anterior    0x004664C8 //x9  { dato=20 sig=0x003F50D0 } nodo*
  169. +       anterior->sig   0x003F50D0 //x12 { dato=30 sig=0x00000000 } nodo*
  170. +       nuevo       0x00466420 //x36 { dato=25 sig=0x00000000 } nodo*
  171. +       nuevo->sig  0x00000000  nodo*
  172.  
  173. //anterior->sig=nuevo;
  174. +       anterior    0x004664C8 //x9 { dato=20 sig=0x003F50D0 }  nodo*
  175. +       anterior->sig   0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  176. +       nuevo       0x00466420 //x36{ dato=25 sig=0x003F50D0 }  nodo*
  177. +       nuevo->sig  0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  178.  
  179. //
  180.  
  181. +       anterior    0x004664C8 //x9 { dato=20 sig=0x00466420 }  nodo*
  182. +       anterior->sig   0x00466420 //x36{ dato=25 sig=0x003F50D0 }  nodo*
  183. +       nuevo       0x00466420 //x36{ dato=25 sig=0x003F50D0 }  nodo*
  184. +       nuevo->sig  0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  185.  
  186. // Introducido 35
  187.  
  188. +       inicial 0x004663D8  //x24 { dato=5 sig=0x00400AC8 } nodo*
  189. +       nuevo   0x00466468  //x42 { dato=35 sig=0x00000000 }    nodo*
  190.         nuevo->dato 35  int
  191.  
  192. // anterior=buscarLista(nuevo->dato);
  193.  
  194. +       anterior    0x004664C8 //x9 { dato=20 sig=0x00466420 }  nodo*
  195. +       nuevo       0x00466468 //x42{ dato=35 sig=0x00000000 }  nodo*
  196.         nuevo->dato 35  int
  197.  
  198.  
  199. // Primer while - listabuscar();
  200.  
  201. +       anterior    0x004663D8 //x24 { dato=5 sig=0x00400AC8 }  nodo*
  202. +       anterior->sig   0x00400AC8 //x4  { dato=10 sig=0x004664C8 } nodo*
  203.         anterior->sig->dato 10  int
  204.         clave   35  int
  205. +       inicial     0x004663D8 //x24 { dato=5 sig=0x00400AC8 }  nodo*
  206.  
  207. // Segundo while - listabuscar();
  208. +       anterior    0x00400AC8 //x4{ dato=10 sig=0x004664C8 }   nodo*
  209. +       anterior->sig   0x004664C8 //x9{ dato=20 sig=0x00466420 }   nodo*
  210.         anterior->sig->dato 20  int
  211.         clave   35  int
  212. +       inicial     0x004663D8 //x24 { dato=5 sig=0x00400AC8 }  nodo*
  213.  
  214. // Tercer while - listabuscar();
  215. +       anterior    0x004664C8 //x9 { dato=20 sig=0x00466420 }  nodo*
  216. +       anterior->sig   0x00466420 //x36{ dato=25 sig=0x003F50D0 }  nodo*
  217.         anterior->sig->dato 25  int
  218.         clave   35  int
  219. +       inicial     0x004663D8 //x24{ dato=5 sig=0x00400AC8 }   nodo*
  220.  
  221. // Cuarto while - listabuscar();
  222.  
  223. +       anterior    0x00466420 //x36{ dato=25 sig=0x003F50D0 }  nodo*
  224. +       anterior->sig   0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  225.         anterior->sig->dato 30  int
  226.         clave   35  int
  227. +       inicial     0x004663D8 //x24{ dato=5 sig=0x00400AC8 }   nodo*
  228.  
  229. // Quinto while - listabuscar();
  230. +       anterior    0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  231. +       anterior->sig   0x00000000  nodo*
  232.         clave   35  int
  233. +       inicial     0x004663D8 //x24{ dato=5 sig=0x00400AC8 }   nodo*
  234.  
  235. // Return anterior:
  236.  
  237. +       anterior    0x003F50D0 //x30{ dato=30 sig=0x00000000 }  nodo*
  238. +       anterior->sig   0x00000000  nodo*
  239.         clave   35  int
  240. +       inicial     0x004663D8 //x24{ dato=5 sig=0x00400AC8 }   nodo*
  241.  
  242. // anterior=buscarLista(nuevo->dato); 
  243.  
  244. +       anterior    0x004664C8 //x9{ dato=20 sig=0x00466420 }   nodo*
  245. +       nuevo       0x00466468 //x42{ dato=35 sig=0x00000000 }  nodo*
  246.         nuevo->dato 35  int
  247.  
  248. // nuevo->sig=NULL; 
  249.  
  250. +       nuevo   0x00466468 { dato=35 sig=0x00000000 }   nodo*
  251. +       nuevo->sig  0x00000000  nodo*
  252.  
  253. // anterior->sig=nuevo;
  254.  
  255. +       anterior    0x003F50D0 //x12{ dato=30 sig=0x00000000 }  nodo*
  256. +       anterior->sig   0x00000000  nodo*
  257. +       nuevo       0x00466468 //x42{ dato=35 sig=0x00000000 }  nodo*
  258. +       nuevo->sig  0x00000000  nodo*
  #8 (permalink)  
Antiguo 22/07/2013, 21:10
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Sonrisa Respuesta: Guia_Listas_Enlazadas - C++
Código C++: 
Ver original
  1. // Introducido 30
  2.  
  3. +       inicial     0x004663D8 //x24 { dato=5 sig=0x00400AC8 }  nodo*
  4. +       nuevo       0x003F5408 //x46 { dato=30 sig=0x00000000 } nodo*
  5.         nuevo->dato 30  int
  6.  
  7. +       anterior    0x003F50D0 //x12{ dato=30 sig=0x00466468 }  nodo*
  8. +       nuevo       0x003F5408 //x46{ dato=30 sig=0x00000000 }  nodo*
  9.         nuevo->dato 30  int
  10.  
  11. // Primer while - listabuscar();
  12. +       anterior    0x004663D8 { dato=5 sig=0x00400AC8 }    nodo*
  13. +       anterior->sig   0x00400AC8 { dato=10 sig=0x004664C8 }   nodo*
  14.         anterior->sig->dato 10  int
  15.         clave   30  int
  16. +       inicial 0x004663D8 { dato=5 sig=0x00400AC8 }    nodo*
  17.  
  18. // Segundo while - listabuscar();
  19. +       anterior    0x00400AC8 { dato=10 sig=0x004664C8 }   nodo*
  20. +       anterior->sig   0x004664C8 { dato=20 sig=0x00466420 }   nodo*
  21. +       anterior->sig->dato 20  int
  22. +       inicial     0x004663D8 { dato=5 sig=0x00400AC8 }    nodo*
  23.  
  24. // Tercero while - listabuscar();
  25. +       anterior    0x004664C8 { dato=20 sig=0x00466420 }   nodo*
  26. +       anterior->sig   0x00466420 { dato=25 sig=0x003F50D0 }   nodo*
  27.         anterior->sig->dato 25  int
  28.         clave   30  int
  29. +       inicial     0x004663D8 { dato=5 sig=0x00400AC8 }    nodo*
  30.  
  31. // Cuarto while - listabuscar();
  32. +       anterior    0x00466420 { dato=25 sig=0x003F50D0 }   nodo*
  33. +       anterior->sig   0x003F50D0 { dato=30 sig=0x00466468 }   nodo*
  34.         anterior->sig->dato 30  int
  35.         clave   30  int
  36. +       inicial     0x004663D8 { dato=5 sig=0x00400AC8 }    nodo*
  37.  
  38. // Quinto while - listabuscar();
  39. +       anterior    0x003F50D0 { dato=30 sig=0x00466468 }   nodo*
  40. +       nuevo       0x003F5408 { dato=30 sig=0x00000000 }   nodo*
  41.         nuevo->dato 30  int
  42.  
  43. // Final!!!
  44. +       anterior    0x00466420 { dato=25 sig=0x003F50D0 }   nodo*
  45. +       anterior->sig   0x003F50D0 { dato=30 sig=0x00466468 }   nodo*
  46. +       nuevo   0x003F5408 { dato=30 sig=0x003F50D0 }   nodo*
  47. +       nuevo->sig  0x003F50D0 { dato=30 sig=0x00466468 }   nodo*
  48.  
  49. // Final - Definitivo!!
  50. +       anterior    0x00466420 { dato=25 sig=0x003F5408 }   nodo*
  51. +       anterior->sig   0x003F5408 { dato=30 sig=0x003F50D0 }   nodo*
  52. +       nuevo       0x003F5408 { dato=30 sig=0x003F50D0 }   nodo*
  53. +       nuevo->sig  0x003F50D0 { dato=30 sig=0x00466468 }   nodo*

Ahora bien, finalmente la lista quedaria así al final:

Código PHP: 
Ver original
  1. X24       X4       X9      X36     X12     X46      X42
  2.  
  3. 4        10       20       25       30       30      35

:D ¿Qué opinas? :D[/HIGHLIGHT]
Última edición por ambigus; 22/07/2013 a las 21:15
  #9 (permalink)  
Antiguo 23/07/2013, 12:37
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
Opino que no veo de donde sale el 4 de x24 :))

Saludos
vosk
  #10 (permalink)  
Antiguo 24/07/2013, 16:06
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Pregunta Respuesta: Guia_Listas_Enlazadas - C++
Jajajaja perdón es 5 con memoria x24 :)

Muchos números xD

Amigo, mira estoy intentando hacer el literal b) y este es el código que propongo, pero nosé qué esta mal con él :(

b) Corregir la función agregar de tal forma que no permita agergar nodos con claves repetidas. La función, en caso de intentar agregar una clave ya existente, debe mostrar el siguiente mensaje: "El nodo a agregar ya existe".

Código C++: 
Ver original
  1. // Agrega_Clase_ListaSE.cpp: archivo de proyecto principal.
  2.  
  3. #include "stdafx.h"
  4. #include "iostream"
  5. #include <conio.h>
  6. using namespace System;
  7. using namespace std;
  8. struct nodo 
  9. {
  10.     int dato;
  11.     nodo *sig;
  12. };
  13. class Lse 
  14. {
  15. private:
  16.     nodo *inicial;
  17.     nodo *buscarLista(int clave); 
  18. public:
  19.     Lse();
  20.     ~Lse();
  21.     void agregar();
  22.     void eliminar();
  23.     void desplegarLista();
  24. };
  25. Lse::Lse()
  26. {
  27.     inicial=NULL;
  28. }
  29. Lse::~Lse ()
  30. {
  31. }
  32. void Lse::desplegarLista()
  33. {
  34.     if(inicial==NULL)
  35.     {
  36.         cout<<"La lista esta vacia"<<endl;
  37.     }
  38.     else
  39.     {
  40.         nodo *apunt;
  41.         apunt=inicial;
  42.         while(apunt!=NULL)
  43.         {
  44.             cout<<apunt->dato<<endl;
  45.             apunt=apunt->sig;
  46.         }
  47.     }   
  48. }
  49. nodo *Lse::buscarLista(int clave)
  50. {
  51.     //Devuelve la dirección del nodo que antecede al nuevo //nodo que va a ser agregado, o que va a ser eliminado.
  52.     //Si la clave es menor o igual al dato del primer nodo //el valor devuelto es NULL.
  53.     //Si la clave es mayor que el dato del último nodo //devuelve la dirección del último nodo.
  54.  
  55.     nodo *anterior; // Anterior AUXILIAR
  56.     anterior=NULL;
  57.     if(clave <= inicial->dato)return anterior;
  58.     else
  59.     {
  60.         anterior=inicial;
  61.         while ( ( anterior->sig!=NULL) && (clave > anterior->sig->dato) )
  62.                                                   anterior=anterior->sig; 
  63.         return anterior;
  64.     }
  65. }
  66. void Lse::agregar()
  67. {
  68.     nodo *nuevo,*anterior,*apunt; 
  69.     char resp;
  70.     do 
  71.     {
  72.         nuevo=new nodo();
  73.         cout<<"Entre clave del nodo a agregar"<<endl;
  74.         cin>>nuevo->dato;
  75.         if(inicial==NULL)
  76.         {
  77.             //Agrega el primer nodo a la lista
  78.             inicial=nuevo; 
  79.             nuevo->sig=NULL;
  80.         }
  81.         else
  82.         {
  83.             //Agrega a una lista que contiene al menos un nodo
  84.             apunt=inicial;
  85.             while(apunt->sig!=NULL)
  86.             {
  87.                 if(nuevo->dato==apunt->dato)
  88.                 {
  89.                     cout<<"El nodo a agregar ya existe"<<endl;
  90.                     delete nuevo;
  91.                 }
  92.                 apunt=apunt->sig;
  93.             };
  94.             anterior=buscarLista(nuevo->dato); 
  95.             if(anterior==NULL)
  96.             {
  97.                 //Agrega un nodo que queda de primero 
  98.                 //en una lista que no estaba vacia
  99.                 nuevo->sig=inicial; 
  100.                 inicial=nuevo;
  101.             }
  102.             else
  103.             {
  104.                 if(anterior->sig!=NULL)
  105.                 {
  106.                     //Agrega un nodo que queda entre el 
  107.                     //primero y el ultimo
  108.                     nuevo->sig=anterior->sig;
  109.                     anterior->sig=nuevo;
  110.                 }
  111.                 else
  112.                 {
  113.                     //Agrega un nodo que queda de ultimo 
  114.                     nuevo->sig=NULL; 
  115.                     anterior->sig=nuevo;
  116.                 }
  117.             }
  118.         }
  119.         cout<<"Desea agregar otro nodo? (s/n)"<<endl; 
  120.         cin>>resp; 
  121.         resp=tolower(resp);
  122.     }while(resp=='s');
  123. }
  124. void main()
  125. {
  126.     Lse l;
  127.     l.agregar();
  128.     l.desplegarLista();
  129.     getch();
  130. }

Espero una pronta respuesta.
  #11 (permalink)  
Antiguo 24/07/2013, 19:08
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Respuesta: Guia_Listas_Enlazadas - C++
Jejejjee mañana tengo un Quiz, y me gustaría saber si lo que he hecho está bien :)

Simulacro del Quiz



http://farm3.staticflickr.com/2852/9...35673a2a_o.jpg

Gracias de antemano ;)
  #12 (permalink)  
Antiguo 25/07/2013, 13:03
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
En la funcion 'agregar' cuando detectas una repeticion debes salir del ciclo, o como minimo no usar los datos eliminados; pon el caso que intentas poner una repeticion en este ciclo:

Código C++: 
Ver original
  1. while(apunt->sig != NULL) {
  2.     if(nuevo->dato == apunt->dato) {
  3.         cout << "El nodo a agregar ya existe" << endl;
  4.         delete nuevo;
  5.     }
  6.     apunt = apunt->sig;
  7. }
  8. anterior = buscarLista(nuevo->dato);

Cuando eliminas 'nuevo' ya no debes trabajar con ese puntero, aun cuando puede quedar memoria basura no será accesible, por eso cuando 'nuevo' está eliminado y no sales del ciclo lo siguiente que haces es 'buscarLista' enviando como argumento algo a lo que ya no tienes acceso:

Código C++: 
Ver original
  1. delete nuevo;
  2. anterior = buscarLista(nuevo->dato);//violacion de segmento

Lo que debes hacer es solicitar el nuevo dato, buscar si existe, si existe notificas el error, preguntas si quiere seguir, si no existe bloqueas memoria para el nuevo nodo y lo añades a la lista. Y para estar aun mas perfecto deberias separar las funciones de insertar de las de popular datos: la funcion de popular datos sería el ciclo de añadir mas datos, solicita un dato y lo busca, si existe notifica el error y continua, si no existe llama a la funcion que inserte el nodo.

Saludos
vosk
  #13 (permalink)  
Antiguo 28/07/2013, 11:53
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Pregunta Respuesta: Guia_Listas_Enlazadas - C++
¿Esta función me sirve?

Código C++: 
Ver original
  1. void Lsec::eliminarNodo()
  2. {
  3.     nodo *aux,*apunt;
  4.     aux=inicial;
  5.     cout<<"Entre clave del nodo a eliminar"<<endl;
  6.     cin>>apunt->dato;
  7.     while(aux->sig!=apunt)
  8.         {aux=aux->sig;}
  9.     aux->sig=apunt->sig;
  10.     delete apunt;
  11.     cout<<"El nodo ha sido eliminado"<<endl;
  12. }
  #14 (permalink)  
Antiguo 28/07/2013, 15:23
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Respuesta: Guia_Listas_Enlazadas - C++
Después de trabajar he logrado esto:

Código C++: 
Ver original
  1. void Lsec::eliminarNodo()
  2. {
  3.     nodo *apunt;
  4.     char resp;
  5.     int aux;
  6.     
  7.     apunt=new nodo();
  8.     apunt=inicial;
  9.     cout<<"Entre clave del nodo a eliminar"<<endl;
  10.     cin>>aux;
  11.     while(aux!=apunt->dato)
  12.     {
  13.         apunt=apunt->sig;
  14.     }
  15.     
  16.     delete apunt;
  17.     cout<<"Listo!!!"<<endl;
  18. }
  #15 (permalink)  
Antiguo 28/07/2013, 15:57
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
Código C: 
Ver original
  1. while(aux!=apunt->dato)
  2.     {
  3.         apunt=apunt->sig;
  4.     }

Y que sucede si entras un valor que no está en la lista? Primero que teoricamente entra en un bucle infinito, y segundo que nunca llegará a entrar en el bucle infinito porque el ultimo elemento de la lista tiene sig=NULL, es decir que en la primera iteracion de lo que sería bucle infinito provocas una violacion de segmento al intentar acceder al 'dato' de un 'apunt' nulo.

No iteres sobre el valor esperado sino sobre la lista; recorre la lista buscando la colision con el dato entrado, y solo intenta eliminarlo en caso que exista. Para cada nodo deberas guardar un puntero a su elemento anterior, de forma que si tienes a->b->c y quieres borrar 'b', deberas asignar 'c' al siguiente de 'a' ok? De lo contrario nunca podras recuperar los datos ni para liberar la memoria bloqueada (al menos durante la ejecucion).

Saludos
vosk
  #16 (permalink)  
Antiguo 28/07/2013, 18:18
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Respuesta: Guia_Listas_Enlazadas - C++
Comprendo, ¿Debo recorrer la lista dentro de la funcion eliminar?
  #17 (permalink)  
Antiguo 28/07/2013, 18:49
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Exclamación Respuesta: Guia_Listas_Enlazadas - C++
¿Porqué no corre? :(

Código C++: 
Ver original
  1. // Agrega_Clase_ListaSE.cpp: archivo de proyecto principal.
  2.  
  3. #include "stdafx.h"
  4. #include "iostream"
  5. #include <conio.h>
  6. using namespace System;
  7. using namespace std;
  8. struct nodo 
  9. {
  10.         int dato;
  11.         nodo *sig;
  12. };
  13. class Lsec 
  14. {
  15. private:
  16.         nodo *inicial;
  17.         nodo *buscarLista(int clave);
  18.         nodo *buscarUltimo();
  19. public:
  20.         Lsec();
  21.         ~Lsec();
  22.         void agregar();
  23.         void eliminarNodo();
  24.         void desplegarLista();
  25. };
  26. Lsec::Lsec()
  27. {
  28.         inicial=NULL;
  29. }
  30. Lsec::~Lsec ()
  31. {
  32. }
  33. void Lsec::desplegarLista()
  34. {
  35.         if(inicial==NULL)
  36.         {
  37.                 cout<<"La lista esta vacia"<<endl;
  38.         }
  39.         else
  40.         {
  41.                 nodo *apunt;
  42.                 apunt=inicial;
  43.                 do
  44.                 {
  45.                         cout<<apunt->dato<<endl;
  46.                         apunt=apunt->sig;
  47.                 }while(apunt!=inicial); 
  48.         }
  49. }
  50. nodo *Lsec::buscarUltimo()
  51. {
  52.                 nodo *ultimo;
  53.                 ultimo=inicial;
  54.                 while(ultimo->sig!=inicial)ultimo=ultimo->sig;
  55.                 return ultimo;
  56. }
  57. void Lsec::eliminarNodo()
  58. {
  59.         nodo *apunt;
  60.         char resp;
  61.         int aux;
  62.         
  63.         apunt=new nodo();
  64.         apunt=inicial;
  65.         cout<<"Entre clave del nodo a eliminar"<<endl;
  66.         cin>>aux;
  67.         while(aux!=apunt->dato)
  68.         {
  69.                 apunt=apunt->sig;
  70.         }
  71.         delete apunt;
  72.         cout<<"Listo!!!"<<endl;
  73. }
  74.  
  75.  
  76. nodo *Lsec::buscarLista(int clave)
  77. {
  78.         //Devuelve la dirección del nodo que antecede al nuevo //nodo que va a ser agregado, o que va a ser eliminado.
  79.         //Si la clave es menor o igual al dato del primer nodo //el valor devuelto es NULL.
  80.         //Si la clave es mayor que el dato del último nodo //devuelve la dirección del último nodo.
  81.  
  82.         nodo *anterior; // Anterior AUXILIAR
  83.         anterior=NULL;
  84.         if(clave <= inicial->dato)return anterior;
  85.         else
  86.         {
  87.                 anterior=inicial;
  88.                 while ((clave > anterior->sig->dato) &&  ( anterior->sig!=inicial)  )
  89.                                                                                                   anterior=anterior->sig; 
  90.                 return anterior;
  91.         }
  92. }
  93. void Lsec::agregar()
  94. {
  95.         nodo *nuevo,*anterior,*apunt,*clavenodo; 
  96.         char resp;
  97.         do 
  98.         {
  99.                 nuevo=new nodo();
  100.                 cout<<"Entre clave del nodo a agregar"<<endl;
  101.                 cin>>nuevo->dato;
  102.                 if(inicial==NULL)
  103.                 {
  104.                         //Agrega el primer nodo a la lista
  105.                         inicial=nuevo; 
  106.                         nuevo->sig=nuevo;
  107.                 }
  108.                 else
  109.                 {
  110.                         //Agrega a una lista que contiene al menos un nodo
  111.                         anterior=buscarLista(nuevo->dato); 
  112.                         if(anterior==NULL)
  113.                         {
  114.                                 //Agrega un nodo que queda de primero 
  115.                                 //en una lista que no estaba vacia
  116.                                 nodo *ultimo;
  117.                                 ultimo=buscarUltimo();
  118.                                 ultimo->sig=nuevo;
  119.                                 nuevo->sig=inicial; 
  120.                                 inicial=nuevo;
  121.                         }
  122.                         else
  123.                         {
  124.                                         nuevo->sig=anterior->sig;
  125.                                         anterior->sig=nuevo;
  126.                         }
  127.                 }
  128.                 cout<<"Desea agregar otro nodo? (s/n)"<<endl; 
  129.                 cin>>resp; 
  130.                 resp=tolower(resp);
  131.         }while(resp=='s');
  132.  
  133.                         
  134. }
  135. void main()
  136. {
  137.         Lsec l;
  138.         l.agregar();
  139.         l.desplegarLista();
  140.         l.eliminarNodo();
  141.         l.desplegarLista();
  142.         getch();
  143. }
  #18 (permalink)  
Antiguo 29/07/2013, 12:42
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
Pero si te lo acabo de comentar: si tienes a->b->c y quieres eliminar 'b', tendras que reasignar 'c' como siguiente de 'a', de lo contrario en el siguiente volcado de la lista estaras accediendo a bloques de memoria no accesibles desde la aplicacion:

Código C: 
Ver original
  1. [inicial] = nodo 0
  2. [nodo 0] -> siguiente = nodo 1
  3. [nodo 1] -> siguiente = nodo 2
  4. [nodo 2] -> siguiente = nulo

El puntero siguiente que tienes en 'nodo0' apunta a la direccion de memoria que bloqueas para 'nodo1'; si eliminas 'nodo1' el siguiente de 'nodo0' seguirá apuntando a esa misma direccion de memoria, excepto que una vez la has liberado (delete) ya no es accesible por tu aplicacion aun cuando contenga algun tipo de dato.

Saludos
vosk
  #19 (permalink)  
Antiguo 29/07/2013, 12:51
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
Otra cosa, en la funcion 'agregar()' quita la parte de codigo que añade el nuevo nodo y ponlo como una funcion independiente, de esta forma cuando necesites testar la aplicacion podras popular la lista de forma automatica.

Aun otra cosa, la funcion main se define de tipo entero, debes declararla como tal y retornar un entero (0 por defecto).

Y otra: la cabecera 'conio' no es estandar; si solo la usas para el 'getch' puedes cambiarla por la funcion 'getchar()' que está en la cabecera 'stdio'.

Y lo ultimo: antes de finalizar la aplicacion debes vaciar toda la memoria que has bloqueado con 'new'; aunque actualmente no sea necesario (todos los s.o. actuales recuperan la memoria bloqueada dinamicamente al finalizar la aplicacion) es una buena práctica y ademas es necesario cuando quieras reusar tu codigo en una misma aplicacion.

Saludos
vosk
  #20 (permalink)  
Antiguo 29/07/2013, 19:25
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Pregunta Respuesta: Guia_Listas_Enlazadas - C++
¿Porqué no me funciona? :(

Código C++: 
Ver original
  1. void Lsec::eliminarNodo()
  2. {
  3.     nodo *aux,*apunt2;
  4.     char resp;
  5.     
  6.     apunt2=new nodo();
  7.     aux=new nodo();
  8.     aux=inicial;
  9.     cout<<"Entre clave del nodo a eliminar"<<endl;
  10.     cin>>apunt2->dato;
  11.     while(aux->dato!=apunt2->dato)
  12.     {
  13.         aux=aux->sig;
  14.     }
  15.     aux->sig=apunt2->sig;
  16.     delete apunt2;
  17.     cout<<"Listo!!!"<<endl;
  18. }
  #21 (permalink)  
Antiguo 29/07/2013, 20:15
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Respuesta: Guia_Listas_Enlazadas - C++
Una mejora:

Código C++: 
Ver original
  1. void Lsec::eliminarNodo()
  2. {
  3.     nodo *aux,*apunt;
  4.     char resp;
  5.     
  6.     apunt=new nodo();
  7.     aux=new nodo();
  8.     aux=inicial;
  9.     cout<<"Entre clave del nodo a eliminar"<<endl;
  10.     cin>>apunt->dato;
  11.     while(aux->sig!=inicial)
  12.     {
  13.         if(apunt->dato==aux->dato)
  14.         {
  15.             
  16.         }
  17.         aux=aux->sig;   
  18.     }
  19.     aux->sig=apunt->sig;
  20.     delete apunt;
  21.     cout<<"Listo!!!"<<endl;
  22. }
  #22 (permalink)  
Antiguo 29/07/2013, 21:12
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Respuesta: Guia_Listas_Enlazadas - C++
Lo máximo que he logrado :( Y nada :(

Código C++: 
Ver original
  1. void Lsec::eliminarNodo()
  2. {
  3.     nodo *aux,*apunt;
  4.     char resp;
  5.     
  6.     apunt=new nodo();
  7.     aux=new nodo();
  8.     aux=inicial;
  9.     cout<<"Entre clave del nodo a eliminar"<<endl;
  10.     cin>>apunt->dato;
  11.     while(aux->sig!=inicial)
  12.     {
  13.         if(apunt->dato==aux->dato)
  14.         {
  15.             aux->sig=apunt->sig;
  16.             delete apunt;
  17.             break;
  18.         }
  19.         else{
  20.             aux=aux->sig;   
  21.         }
  22.         
  23.     }
  24.     cout<<"Listo!!!"<<endl;
  25. }
  #23 (permalink)  
Antiguo 29/07/2013, 21:33
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Respuesta: Guia_Listas_Enlazadas - C++
Me rindo :( NO´se qué hacer :( :( :( :(

Código C++: 
Ver original
  1. void Lsec::eliminarNodo()
  2. {
  3.     nodo *aux,*apunt;
  4.     char resp;
  5.     
  6.     apunt=new nodo();
  7.     aux=new nodo();
  8.     aux=inicial;
  9.     cout<<"Entre clave del nodo a eliminar"<<endl;
  10.     cin>>apunt->dato;
  11.     while(aux->sig!=inicial && aux->sig!=apunt)
  12.     {
  13.         aux=aux->sig;
  14.         if(aux->dato==apunt->dato)
  15.         {
  16.             aux->sig=apunt->sig;
  17.             delete apunt;
  18.         }
  19.     }
  20.     cout<<"Listo!!!"<<endl;
  21. }
  #24 (permalink)  
Antiguo 30/07/2013, 13:46
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
"...Me rindo :( NO´se qué hacer :( :( :( :(..."

Ante todo mucha calma

Te expongo lo que te he comentado tres o cuatro veces: una funcion para solicitar datos y otra para trabajar con la lista, es lo que deberias hacer con las demas funciones que interactuan con la lista (de esta forma puedes testar sin tener que esperar las preguntas de 'otra vez', o lo que sea). Ademas te servirá para cuando quieras mover la aplicacion a entorno grafico :)

Primero declaro una nueva funcion para solicitar el dato del nodo a eliminar:

Código C: 
Ver original
  1. void ask_eliminarNodo(Lsec *lsec) {
  2.     int dato;
  3.  
  4.     //solicito dato
  5.     cout << "Entre clave del nodo a eliminar" << endl;
  6.     cin >> dato;
  7.     
  8.     //ejecuto en el manejador
  9.     if(lsec->eliminarNodo(dato)) {
  10.         cout << "Listo!!!" << endl;
  11.     }
  12.     else {
  13.         cout << "No se encontro el nodo " << dato << endl;
  14.     }
  15. }

Observa que esta funcion no forma parte de la clase, se supone que la clase es un manejador de listas, lo de preguntar cosas queda fuera de las aptitudes de la clase. Lo mismo tienes que hacer para la funcion agregar, buscar y las demas que interactuen.

Ahora pongo la funcion de la clase que elimina un nodo (que es la que te interesa):

Código C: 
Ver original
  1. bool Lsec::eliminarNodo(int dato) {
  2.     nodo *ptr, *prev, *last;
  3.  
  4.     //setup del iterador
  5.     prev = 0;
  6.     ptr = inicial;
  7.     last = buscarUltimo();
  8.  
  9.     //buscamos colision
  10.     while(ptr) {
  11.         if(ptr->dato == dato) {
  12.             break;
  13.         }
  14.         else if(ptr->dato > dato) {
  15.             prev = ptr = 0;
  16.             return 0;
  17.         }
  18.  
  19.         prev = ptr;
  20.         if((ptr = ptr->sig) == last) {
  21.             prev = ptr = 0;
  22.             break;
  23.         }
  24.     }
  25.  
  26.     //validacion
  27.     if(!prev && !ptr) {
  28.         //operacion fallida
  29.         return 0;
  30.     }
  31.  
  32.     //reasignamos siguiente diferenciando entre primer nodo y siguientes
  33.     if(prev) {
  34.         //estamos en segundo o posterior
  35.         prev->sig = ptr->sig;
  36.     }
  37.     else {
  38.         //estamos en primero
  39.         inicial = ptr->sig;
  40.     }
  41.  
  42.     //liberamos memoria
  43.     delete ptr;
  44.  
  45.     //operacion correcta
  46.     return 1;
  47. }

Y ahora solo te queda cambiar la llamada del main a la nueva funcion:

Código C: 
Ver original
  1. Lsec l;
  2. l.agregar();
  3. l.desplegarLista();
  4. ask_eliminarNodo(&l);
  5. ...

Revisa lo que te comenté en el otro post.

Saludos
vosk

p.s. Ahora que me fijo, al ser lista circular tal vez habrá que hacer alguna otra asignacion en la funcion que elimina nodos en el caso que elimine el primero
Última edición por vosk; 30/07/2013 a las 14:45
  #25 (permalink)  
Antiguo 01/08/2013, 05:22
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Pregunta Respuesta: Guia_Listas_Enlazadas - C++
Estoy muy agradecido contigo por tu paciencia y dedicación :)



Y me gustaría compartirte que pues la secuencia de estos códigos los hizo el profesor y él nos hace exámenes en base a este código. Asi pues me gustaría que trabajaramos si es posible en base a este código.

1. ¿Qué estoy omitiendo en este código? - Lo he analizado desde cero y aún no doy con el chiste. El profesor nos recomienda que "Busquemos" el nodo que vamos a eliminar con la función "BuscarLista()". ¿La estoy usando bien?.

Al correr el programa me elimina exitosamente sólo el primero :(.

2. También hay que evitar que se ingresen nodos repetidos. ¿Cómo logro esto modificando la función agregar(); Lo he intentado y resulta que lo que hace es dar con un bucle :(

3. ¿Qué curso de Video-tutorial en español o inglés subtitulado me recomiendas para aprender estos temas?

3.1 Programar C++
3.2 Listas Circular Simplemente enlazadas
3.3 Listas Doblemente enlazadas
3.4 Listas Circular Doblemente Enlazadas
3.5 Pilas
3.6 Colas

Código C++: 
Ver original
  1. // Agrega_Clase_ListaSE.cpp: archivo de proyecto principal.
  2.  
  3. #include "stdafx.h"
  4. #include "iostream"
  5. #include <conio.h>
  6. using namespace System;
  7. using namespace std;
  8. struct nodo 
  9. {
  10.     int dato;
  11.     nodo *sig;
  12. };
  13. class Lsec 
  14. {
  15. private:
  16.     nodo *inicial;
  17.     nodo *buscarLista(int clave);
  18.     nodo *buscarUltimo();
  19. public:
  20.     Lsec();
  21.     ~Lsec();
  22.     void agregar();
  23.     void eliminarNodo();
  24.     void desplegarLista();
  25. };
  26. Lsec::Lsec()
  27. {
  28.     inicial=NULL;
  29. }
  30. Lsec::~Lsec ()
  31. {
  32. }
  33. void Lsec::desplegarLista()
  34. {
  35.     if(inicial==NULL)
  36.     {
  37.         cout<<"La lista esta vacia"<<endl;
  38.     }
  39.     else
  40.     {
  41.         nodo *apunt;
  42.         apunt=inicial;
  43.         cout<<"---LISTA ACTUAL---"<<endl;
  44.         do
  45.         {
  46.             cout<<apunt->dato<<endl;
  47.             apunt=apunt->sig;
  48.         }while(apunt!=inicial); 
  49.     }
  50. }
  51. nodo *Lsec::buscarUltimo()
  52. {
  53.         nodo *ultimo;
  54.         ultimo=inicial;
  55.         while(ultimo->sig!=inicial)ultimo=ultimo->sig;
  56.         return ultimo;
  57. }
  58. void Lsec::eliminarNodo()
  59. {
  60.     nodo *anterior,*apunt,*ultimo;
  61.     char resp;
  62.     
  63.  
  64.     do{
  65.  
  66.     apunt=new nodo();
  67.     anterior=new nodo();
  68.     cout<<"Entre clave del nodo a eliminar"<<endl;
  69.     cin>>apunt->dato;
  70.  
  71.     anterior=buscarLista(apunt->dato);
  72.     if(anterior==NULL)
  73.     {
  74.         if(apunt->dato==inicial->dato)
  75.         {
  76.             ultimo=buscarUltimo();
  77.             inicial->sig=ultimo;
  78.             delete apunt;
  79.         }
  80.         else
  81.         {cout<<"El nodo ha eliminar no existe"<<endl;}
  82.     }
  83.     else
  84.     {
  85.         if(apunt->dato==anterior->sig->dato)
  86.         {
  87.             anterior=anterior->sig->sig;
  88.             delete apunt;
  89.         }
  90.         else
  91.         {cout<<"El nodo ha eliminar no existe"<<endl;}
  92.     }
  93.     desplegarLista();
  94.     cout<<"Desea eliminar otro nodo? (s/n)"<<endl; 
  95.     cin>>resp; 
  96.     resp=tolower(resp);
  97.     }while(resp=='s');
  98.  
  99. }
  100.  
  101.  
  102. nodo *Lsec::buscarLista(int clave)
  103. {
  104.     //Devuelve la dirección del nodo que antecede al nuevo //nodo que va a ser agregado, o que va a ser eliminado.
  105.     //Si la clave es menor o igual al dato del primer nodo //el valor devuelto es NULL.
  106.     //Si la clave es mayor que el dato del último nodo //devuelve la dirección del último nodo.
  107.  
  108.     nodo *anterior; // Anterior AUXILIAR
  109.     anterior=NULL;
  110.     if(clave <= inicial->dato)return anterior;
  111.     else
  112.     {
  113.         anterior=inicial;
  114.         while ((clave > anterior->sig->dato) &&  ( anterior->sig!=inicial)  )
  115.                                                   anterior=anterior->sig; 
  116.         return anterior;
  117.     }
  118. }
  119. void Lsec::agregar()
  120. {
  121.     nodo *nuevo,*anterior,*apunt,*clavenodo; 
  122.     char resp;
  123.     do 
  124.     {
  125.         nuevo=new nodo();
  126.         cout<<"Entre clave del nodo a agregar"<<endl;
  127.         cin>>nuevo->dato;
  128.         if(inicial==NULL)
  129.         {
  130.             //Agrega el primer nodo a la lista
  131.             inicial=nuevo; 
  132.             nuevo->sig=nuevo;
  133.         }
  134.         else
  135.         {
  136.             apunt=inicial;
  137.             do
  138.             {
  139.                 if(nuevo->dato==apunt->dato)
  140.                 {cout<<"Entre clave del nodo a agregar"<<endl;}
  141.                 else
  142.                 {apunt=apunt->sig;}
  143.             }while(apunt!=inicial);
  144.             //Agrega a una lista que contiene al menos un nodo
  145.             anterior=buscarLista(nuevo->dato); 
  146.             if(anterior==NULL)
  147.             {
  148.                 //Agrega un nodo que queda de primero 
  149.                 //en una lista que no estaba vacia
  150.                 nodo *ultimo;
  151.                 ultimo=buscarUltimo();
  152.                 ultimo->sig=nuevo;
  153.                 nuevo->sig=inicial; 
  154.                 inicial=nuevo;
  155.             }
  156.             else
  157.             {
  158.                     nuevo->sig=anterior->sig;
  159.                     anterior->sig=nuevo;
  160.             }
  161.         }
  162.         cout<<"Desea agregar otro nodo? (s/n)"<<endl; 
  163.         cin>>resp; 
  164.         resp=tolower(resp);
  165.     }while(resp=='s');
  166.  
  167.             
  168. }
  169. void main()
  170. {
  171.     Lsec l;
  172.     l.agregar();
  173.     l.desplegarLista();
  174.     l.eliminarNodo();
  175.     l.desplegarLista();
  176.     getch();
  177. }
  #26 (permalink)  
Antiguo 01/08/2013, 13:10
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
"...1. ¿Qué estoy omitiendo en este código?..."

Cuando vas a eliminar un nodo no tienes que reservar memoria para nada, toda la memoria que necesitas ya existe, y lo mismo sucede cuando vas a buscar un nodo; revisa tus apuntes para saber que es una perdida de memoria (memory leak) y para ver que efectos tiene en tu funcion de eliminar:

Código C: 
Ver original
  1. nodo *anterior;//puntero no inicializado
  2. anterior= new nodo();//reserva dinamica de memoria
  3. anterior = buscarLista(apunt->dato);//perdida de memoria


"...El profesor nos recomienda que "Busquemos" el nodo que vamos a eliminar con la función "BuscarLista()". ¿La estoy usando bien?..."

Dos cosas: ¿quien ha escrito esa funcion? y ¿has echo alguna prueba con la funcion de buscar en la lista? Si entro la lista 3,5,7,9 y busco el nodo 5 me retorna 7, si busco el nodo 3 me retorna 7, si busco 1000 me retorna 7, etc


"...También hay que evitar que se ingresen nodos repetidos..."

Es tan simple como parece: pides un dato, lo buscas, si no existe lo añades.

Para que todo esto te resulte mas facil aun y para que puedes crear un codigo amigable te sugiero otra vez que revises las ideas de la POO: la clase Lsec es un manejador de listas, puede agregar datos, eliminar, buscar, pero no puede preguntar al usuario. Los bucles while(resp=='s') no deben formar parte de la clase (al menos no de Lsec o como minimo no deben formar parte de la funcion eliminar: la funcion 'eliminar' elimina, la funcion 'buscar' busca, y la funcion 'preguntar' pregunta, cada cosa se dedica a lo suyo). Con esto obtendras un codigo claro y podras identificar rapidamente los errores.


"... ¿Qué curso de Video-tutorial..."

No he visto nunca ningun videotutorial, no puedo recomendarte ninguno. Una busqueda rapida de <0.2s en google me ha dado esta http://cslibrary.stanford.edu/103/ entrada en 5ª posicion; seguro que en cualquier buscador de torrents encontraras libros escaneados en pdf que te seran de major ayuda, o el la biblioteca de tu facultad tambien tendras disponibles no solo libros sino tambien apuntes, no?

Otra cosa, la funcion de entrada 'main' en el estandar del 99 se define de tipo entero, y como tal debe retornar un entero (no voy a profundizar sobre esto ni si el compilador en c++ adapta el void main a entero y hace que retorne 0 por defecto o lo que sea, tampoco se muy bien como lo hace ni si el resultado es fiable). Por defecto retornará 0, o en caso de error un codigo de identificacion del error (esto sirve para cuando una aplicacion lanza a otra para que haga algo, si lo hace mal o no puede completar se descarta la operacion).

Otra, la libreria conio no es estandar y solo la usas para el getch, incluye la stdio y usa getchar.

Aun otra cosa, en la frase "El nodo ha eliminar no existe" la proposicion 'a' va sin 'h', ('ha' con 'h' es la 3ª p. del presente del verbo 'haber').

Saludos
vosk
Última edición por vosk; 01/08/2013 a las 13:23
  #27 (permalink)  
Antiguo 04/08/2013, 15:50
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Pregunta Respuesta: Guia_Listas_Enlazadas - C++
Finalmente!!! Este código me funciona. Pero a medias :(. No me borra el primero de la lista :( ¿Qué me hace falta?

Código C++: 
Ver original
  1. // Agrega_Clase_ListaSE.cpp: archivo d proyecto principal.
  2.  
  3. #include "stdafx.h"
  4. #include "iostream"
  5. #include <conio.h>
  6. using namespace System;
  7. using namespace std;
  8. struct nodo 
  9. {
  10.     int dato;
  11.     nodo *sig;
  12. };
  13. class Lsec 
  14. {
  15. private:
  16.     nodo *inicial;
  17.     nodo *buscarLista(int clave);
  18.     nodo *buscarUltimo();
  19. public:
  20.     Lsec();
  21.     ~Lsec();
  22.     void agregar();
  23.     void eliminarNodo();
  24.     void desplegarLista();
  25. };
  26. Lsec::Lsec()
  27. {
  28.     inicial=NULL;
  29. }
  30. Lsec::~Lsec ()
  31. {
  32. }
  33. void Lsec::desplegarLista()
  34. {
  35.     if(inicial==NULL)
  36.     {
  37.         cout<<"La lista esta vacia"<<endl;
  38.     }
  39.     else
  40.     {
  41.         nodo *apunt;
  42.         apunt=inicial;
  43.         cout<<"---LISTA ACTUAL---"<<endl;
  44.         do
  45.         {
  46.             cout<<apunt->dato<<endl;
  47.             apunt=apunt->sig;
  48.         }while(apunt!=inicial); 
  49.     }
  50. }
  51. nodo *Lsec::buscarUltimo()
  52. {
  53.         nodo *ultimo;
  54.         ultimo=inicial;
  55.         while(ultimo->sig!=inicial)ultimo=ultimo->sig;
  56.         return ultimo;
  57. }
  58. void Lsec::eliminarNodo()
  59. {
  60.     nodo *anterior,*apunt, *clave;
  61.     char resp;
  62.     
  63.     apunt=new nodo();
  64.     anterior=new nodo();
  65.     clave=new nodo();
  66.  
  67.     do{
  68.         if(inicial==NULL)
  69.         {
  70.             cout<<"La lista esta vacia"<<endl;
  71.         }
  72.         else
  73.         {
  74.             apunt=inicial;
  75.             cout<<"Entre clave del nodo a eliminar"<<endl;
  76.             cin>>clave->dato;
  77.             anterior=buscarLista(clave->dato);
  78.             if(anterior==NULL)
  79.             {
  80.                 if(clave->dato==inicial->dato)
  81.                 {
  82.                     if(inicial->sig==inicial)
  83.                     {
  84.                         inicial=NULL;
  85.                     }
  86.                     else
  87.                     {
  88.                         nodo *ultimo;
  89.                         ultimo=buscarUltimo();
  90.                         ultimo->sig=inicial->sig;
  91.                         
  92.                     }
  93.                 }
  94.                 else
  95.                 {
  96.                     cout<<"El nodo ha eliminar no existe"<<endl;
  97.                 }
  98.                 delete apunt;
  99.             }
  100.             else
  101.             {
  102.                 if(clave->dato==anterior->sig->dato)
  103.                 {
  104.                     apunt=anterior->sig;
  105.                     anterior->sig=anterior->sig->sig;
  106.                     delete apunt;
  107.                 }
  108.                 else
  109.                 {
  110.                     cout<<"El nodo ha eliminar no existe"<<endl;
  111.                 }
  112.             }
  113.         }   
  114.     cout<<"Desea eliminar otro nodo? (s/n)"<<endl; 
  115.     cin>>resp; 
  116.     resp=tolower(resp);
  117.     }while(resp=='s');
  118.  
  119. }
  120.  
  121.  
  122. nodo *Lsec::buscarLista(int clave)
  123. {
  124.     //Devuelve la dirección del nodo que antecede al nuevo //nodo que va a ser agregado, o que va a ser eliminado.
  125.     //Si la clave es menor o igual al dato del primer nodo //el valor devuelto es NULL.
  126.     //Si la clave es mayor que el dato del último nodo //devuelve la dirección del último nodo.
  127.  
  128.     nodo *anterior; // Anterior AUXILIAR
  129.     anterior=NULL;
  130.     if(clave <= inicial->dato)return anterior;
  131.     else
  132.     {
  133.         anterior=inicial;
  134.         while ((clave > anterior->sig->dato) &&  ( anterior->sig!=inicial)  )
  135.                                                   anterior=anterior->sig; 
  136.         return anterior;
  137.     }
  138. }
  139. void Lsec::agregar()
  140. {
  141.     nodo *nuevo,*anterior; 
  142.     char resp;
  143.     do 
  144.     {
  145.         nuevo=new nodo();
  146.         cout<<"Entre clave del nodo a agregar"<<endl;
  147.         cin>>nuevo->dato;
  148.         if(inicial==NULL)
  149.         {
  150.             //Agrega el primer nodo a la lista
  151.             inicial=nuevo; 
  152.             nuevo->sig=nuevo;
  153.         }
  154.         else
  155.         {
  156.             //Agrega a una lista que contiene al menos un nodo
  157.             anterior=buscarLista(nuevo->dato); 
  158.             if(anterior==NULL)
  159.             {
  160.                 //Agrega un nodo que queda de primero 
  161.                 //en una lista que no estaba vacia
  162.                 nodo *ultimo;
  163.                 ultimo=buscarUltimo();
  164.                 ultimo->sig=nuevo;
  165.                 nuevo->sig=inicial; 
  166.                 inicial=nuevo;
  167.             }
  168.             else
  169.             {
  170.                     nuevo->sig=anterior->sig;
  171.                     anterior->sig=nuevo;
  172.             }
  173.         }
  174.         cout<<"Desea agregar otro nodo? (s/n)"<<endl; 
  175.         cin>>resp; 
  176.         resp=tolower(resp);
  177.     }while(resp=='s');      
  178. }
  179. void main()
  180. {
  181.     Lsec l;
  182.     l.agregar();
  183.     l.desplegarLista();
  184.     l.eliminarNodo();
  185.     l.desplegarLista();
  186.  
  187.     getch();
  188. }
  #28 (permalink)  
Antiguo 05/08/2013, 12:43
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
Sigues teniendo el problema de la perdida de memoria; revisa lo que te comenté en el otro post.

Saludos
vosk
  #29 (permalink)  
Antiguo 05/08/2013, 17:36
 
Fecha de Ingreso: septiembre-2008
Mensajes: 221
Antigüedad: 16 años, 3 meses
Puntos: 1
Pregunta Respuesta: Guia_Listas_Enlazadas - C++
Código C++: 
Ver original
  1. // Agrega_Clase_ListaDE.cpp: archivo de proyecto principal.
  2.  
  3. #include "stdafx.h"
  4. #include "iostream"
  5. #include <conio.h>
  6. using namespace System;
  7. using namespace std;
  8. struct nodo 
  9. {
  10.     int dato;
  11.     nodo *ant;
  12.     nodo *sig;
  13. };
  14. class Lde 
  15. {
  16. private:
  17.     nodo *inicial;
  18.     nodo *buscarLista(int clave);
  19. public:
  20.     Lde();
  21.     ~Lde();
  22.     void agregar();
  23.     void eliminarNodo();
  24.     void desplegarLista();  
  25. };
  26. Lde::Lde()
  27. {
  28.     inicial=NULL;
  29. }
  30. Lde::~Lde ()
  31. {
  32. }
  33. void Lde::desplegarLista()
  34. {
  35.     if(inicial==NULL)
  36.     {
  37.         cout<<"La lista esta vacia"<<endl;
  38.     }
  39.     else
  40.     {
  41.         nodo *apunt;
  42.         apunt=inicial;
  43.         while(apunt!=NULL)
  44.         {
  45.             cout<<apunt->dato<<endl;
  46.             apunt=apunt->sig;
  47.         }
  48.     }   
  49. }
  50. nodo *Lde::buscarLista(int clave)
  51. {
  52.     //Devuelve la dirección del nodo que antecede al nuevo //nodo que va a ser agregado, o que va a ser eliminado.
  53.     //Si la clave es menor o igual al dato del primer nodo //el valor devuelto es NULL.
  54.     //Si la clave es mayor que el dato del último nodo //devuelve la dirección del último nodo.
  55.  
  56.     nodo *anterior; // Anterior AUXILIAR
  57.     anterior=NULL;
  58.     if(clave <= inicial->dato)return anterior;
  59.     else
  60.     {
  61.         anterior=inicial;
  62.         while ( ( anterior->sig!=NULL) && (clave > anterior->sig->dato) )
  63.                                                   anterior=anterior->sig; 
  64.         return anterior;
  65.     }
  66. }
  67. void Lde::agregar()
  68. {
  69.     nodo *nuevo,*anterior,*apunt,*clavenodo; 
  70.     char resp;
  71.     do 
  72.     {
  73.         nuevo=new nodo();
  74.         cout<<"Entre clave del nodo a agregar"<<endl;
  75.         cin>>nuevo->dato;
  76.         if(inicial==NULL)
  77.         {
  78.             //Agrega el primer nodo a la lista
  79.             inicial=nuevo;
  80.             nuevo->ant=NULL;
  81.             nuevo->sig=NULL;
  82.         }
  83.         else
  84.         {
  85.             //Agrega a una lista que contiene al menos un nodo
  86.             anterior=buscarLista(nuevo->dato); 
  87.             if(anterior==NULL)
  88.             {
  89.                 //Agrega un nodo que queda de primero 
  90.                 //en una lista que no estaba vacia
  91.                 nuevo->sig=inicial;
  92.                 nuevo->ant=inicial->ant;
  93.                 inicial->ant=nuevo;
  94.                 inicial=nuevo;
  95.             }
  96.             else
  97.             {
  98.                 if(anterior->sig!=NULL)
  99.                 {
  100.                     //Agrega un nodo que queda entre el 
  101.                     //primero y el ultimo
  102.                     nuevo->sig=anterior->sig;
  103.                     nuevo->ant=anterior;
  104.                     anterior->sig->ant=nuevo;
  105.                     anterior->sig=nuevo;
  106.                 }
  107.                 else
  108.                 {
  109.                     //Agrega un nodo que queda de ultimo 
  110.                     nuevo->sig=anterior->sig;
  111.                     nuevo->ant=anterior;
  112.                     anterior->sig=nuevo;
  113.                 }
  114.             }
  115.         }
  116.         cout<<"Desea agregar otro nodo? (s/n)"<<endl; 
  117.         cin>>resp; 
  118.         resp=tolower(resp);
  119.     }while(resp=='s');
  120.  
  121.             
  122. }
  123.  
  124. void Lde::eliminarNodo()
  125. {
  126.     nodo *apunteliminar, *eliminarNodo,*clavenodo;
  127.     char resp;
  128.     apunteliminar=inicial;
  129.  
  130.         cout<<"Desea eliminar un nodo? (y/n)"<<endl; 
  131.         cin>>resp; 
  132.         resp=tolower(resp);
  133.         if(resp=='y')
  134.         {
  135.             clavenodo==NULL;
  136.             cout<<"Digite la clave del nodo que va a eliminar"<<endl; 
  137.             cin>>clavenodo->dato; 
  138.         }
  139.  
  140.     if(apunteliminar->dato==clavenodo->dato)
  141.     {
  142.         delete apunteliminar;
  143.         cout<<"El nodo señalado ha sido eliminado"<<endl;
  144.     }
  145.     else
  146.     {
  147.         cout<<"El nodo señalado no ha sido encontrado"<<endl;
  148.     }
  149. }
  150. void main()
  151. {
  152.     Lde l;
  153.     l.agregar();
  154.     l.desplegarLista();
  155.     getch();
  156. }

En este código. ¿Qué significa la linea de comando

Código C++: 
Ver original
  1. anterior->sig->ant=nuevo;

¿Está bien planteado esta interpretación de "Listas Doblemente Enlazadas?



Gracias de antemano.
  #30 (permalink)  
Antiguo 06/08/2013, 13:24
 
Fecha de Ingreso: agosto-2012
Mensajes: 601
Antigüedad: 12 años, 4 meses
Puntos: 83
Respuesta: Guia_Listas_Enlazadas - C++
"...En este código. ¿Qué significa la linea de comando..."

¿¿Como?? No puedes preguntar eso despues de resolver un ejercicio de listas enlazadas :)) Es una asignacion de punteros.

La implementacion me parece que está bien, solo lo he mirado por encima, pero puedes expandirla asignando el ultimo elemento como anterior del primer elemento y el primer elemento como siguiente del ultimo (de forma parecida a como tenias en la otra lista que el siguiente elemento del ultimo era el primero)

Saludos
vosk

Etiquetas: funcion, int, listas, programa, struct
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta


« Tema Anterior | Próximo Tema »


La zona horaria es GMT -6. Ahora son las 18:01.