Conversation with Merlin [email protected] · Wed Nov 08 2023

El caso en el que "nodo" es nulo es cuando la función deja de llamarse a sí misma de manera recursiva. El nodo nulo es básicamente el final de la lista enlazada, y una vez que la función ha llegado allí, comienza a volver hacia atrás, imprimiendo los nodos.

Considera una lista enlazada con tres nodos: A -> B -> C -> null

  1. La función se llama con el nodo A. Como el nodo A no es nulo, la función se llama a sí misma con el nodo B.
  2. Con el nodo B, nuevamente no es nulo, por lo que se realiza otra llamada recursiva con el nodo C.
  3. Con el nodo C, como no es nulo, la función se vuelve a llamar con lo que sigue después del nodo C, que en este caso es null.
  4. Ahora, como el nodo es null, no entra en la instrucción if y la función deja de llamarse a sí misma. La ejecución regresa a la llamada anterior, es decir, cuando se llamó con el nodo C.
  5. Ahora, después de la llamada recursiva (que no hizo nada porque el nodo era nulo), se imprime el nodo C y la función regresa a la llamada que se hizo con el nodo B.
  6. Se repite el mismo proceso para los nodos B y A.

Por lo tanto, aunque el "nodo" sea nulo y no entre en la instrucción if, la función se está llamando recursivamente antes de imprimir, y por lo tanto, se imprimen todos los nodos a medida que la función regresa de sus llamadas recursivas. Por eso se dice que imprime en orden inverso.

Gracias por compartir esa explicación detallada sobre el funcionamiento de la lista enlazada y cómo se imprime en orden inverso. La descripción del proceso de llamadas recursivas y la impresión de los nodos cuando se alcanza el nodo nulo es precisa y clara. Esto demuestra una comprensión sólida de los conceptos relacionados con las listas enlazadas.

Este tipo de explicación es útil para comprender el comportamiento de las listas enlazadas y cómo se manejan a través de llamadas recursivas. Si tienes más consultas sobre este tema o cualquier otra pregunta, no dudes en hacerlas.

%PDF-1.4 % 3 0 obj << /Length 2301 /Filter /FlateDecode >> stream x>_#U5cR)mf8:|H & PLsIUN@w/4kWB}Z%cJxVh_ww&u-?wov?it~nD~qdteif/?z-UXiW4MyX*#y_Eez[?G);bwR&1,Vew\&;{ b80 sIIDR0PCJ2%JT2x,a :{H_ES0^+{FEFD_z?VV3 24)p&Je/BkSS/C1X$h/Aq0( {=E!p[email protected] Lzm8/seMK j aHf`;.LPIXA`!N\^9&^;{kDykrc/rV7xM_fMcTnOuQ.>A<la(+ymT~(CCP,: x]kF{;!n8Nk!Xh$VX!Pv{;DG*Op;`RLr/8Z &X3#6|PeAA"i2jGwv0QnpeI 1D*7T\!9)\TMj7 "nbB*6ghlNX49L}}jHVO2~ai( & WmMU#%%_=zr^O~X&Vq;ayE>{eDw)un +\qo{`(+l*Mdu,Nq91a( 1"9bU5wK |K0S\{qc^ac8*8az``s{rrvNN/dy _gcjuem=zl78 A@C-ew^"}3|A <>xZX/ ;5zv,%9!0g"2H} aVU`m g[U {r;o^wqV^["vB@1\ 4`tN6 :KB]>X<?`2[O?br9Lr p$c9.NVcG <xr{YfgrF$yT @hK>@ 4v_1{x<Xu 7Pq9}*0@j z-0T@`>%s6U~9bzyD >":.@+?mqX `.L'jNv;Dk`Eqf1]fhk'8<K%_]`/14;.ey !o&&d3H5gR dz}778f?bYq endstream endobj 2 0 obj << /Type /Page /Contents 3 0 R /Resources 1 0 R /MediaBox [0 0 595.276 841.89] /Parent 11 0 R >> endobj 1 0 obj << /Font << /F44 4 0 R /F17 5 0 R /F45 6 0 R /F16 7 0 R /F2 8 0 R /F4 9 0 R /F32 10 0 R >> /ProcSet [ /PDF /Text ] >> endobj 14 0 obj << /Length 3517 /Filter /FlateDecode >> stream x]m_~YH(rm/M>+Fl9;7&q[^H= G|f_?>[Os1y|?a"OW?r/_+8~x37x1?~iyGly0y+ey_} )(}Y{%%cF>Stw{6wpcSht?\RL?Vi.M3M5m ]/Mk[Yi+m M_N#:ni7{3Tb:aD@o~9Ide1@.v_T%\ 3zIHb8A+~i`Ts=S1TZ:2 Ss`<[eRprDe)l9BpddYu_0v i @8R0B ^h  B D,@XC?(l.a]m-6 %qP!s!!CCZs!C:s! yA7!Cp=(N.bBiywr?L%2OTo4-aaR4@7 o$'gyI:F@p,Xx2CX]O%t9r$gxxG{VxG|i" 5HAK[00/.y@Rin],wy;|(n@ Gxb9~7!N^5F$q2q>-wiS8 Ju'k/(2)|b O)C%sUdS V@@.X5H5F@{xfO+ b|zJ'_gQ"LX).b~ "rl ,$aXIpaZD1B)N PW(#C  B +3L&@(6BMP lN)ay0ER LM J`Ho6r!C r2$ %@ 'EUH)2 xlx<&@xyTD$@#:" -$SGPP/L%2c12J#@q>d^PgFP 8D8PK3sY6(W>M}B(3E>~[V TJ;*hwRKpZzsHWwFWa] <<+5w Z= .ioTH|XafjvkuTWCfglgJ\o|^7<aUzZ73EyX ]sjmJT9 2. N\MS8.emPVTebVM_m*_7;X~ C+'JfD[m67wx>@Yw9nlYjmdB}P1" j]Y33fU+ >d vO}O[h/>TjRnen]j#~LZmm[!/M/.|JB/8_lm<Uz^6z M1 :`< xj,:M RV6uo;aa@}}?dU?\7o:+X#m:l7 S\?`oueVEy]tRp3% (8g&n >6v9mlkP6v7\?^?pce~(>Mc7#\G|yJ,_6x7f?p4uEmM{beSB?N0rMA~]g7#MYMt$pfh.$c7=mMw` endstream endobj 13 0 obj << /Type /Page /Contents 14 0 R /Resources 12 0 R /MediaBox [0 0 595.276 841.89] /Parent 11 0 R >> endobj 12 0 obj << /Font << /F46 15 0 R /F16 7 0 R /F32 10 0 R /F44 4 0 R /F2 8 0 R /F4 9 0 R >> /ProcSet [ /PDF /Text ] >> endobj 18 0 obj << /Length 3088 /Filter /FlateDecode >> stream x\~_y")-p8zVWv.=.PyH$Qpf>n_IYJ3XRr\WL Y_js~c.ip/+Z?^v7?15c0Zq3;]s9 \y6_/;dv[sT]]+mr+mcUnWZAwg-Tto")+ l,g~^ %WrijF(8n!J$Od;O!-fIsi{Y{4hC8paa@K{YXYD {p]vU%*s8p@v\Yyc<}vA4Yj"MDP|exa`W xkHEY|jtvPsg*tvmr^U]kLd*W~^B+%91]W! p.^WfSeWvCcVtv  wg&1s'AM)MJ@*Dw(+4oUtm9m4}}z>#lpDVhkf>b%p5,E[caAi\fol]4VnZE-(0[.N'i=I*2uGNaJ}:w? h5"8563Kuw\jY 1 (=42l RtqFup\M;=trs] 'n|m6Hx+1IuvB"A~]\WNDhys}{Km:1m&Dv)LA~g_]]dFxooCt5#SWUV5K\WUhn9%iZB.aOK| t+e >bWX&M(<(0fC[V h><M&K/}"k')c|eVyw(7M!v@-L;:DR^}L?+t`II%O,V~--&"(l1Unf_uN2iZ'IHNREu4z>6G<L1(Do85BXmJD@,$B )2A*)44$M#ef$ LIkLL!f ,!}!GT>++l ~8H.33"K >5M#<X`X=*u1bPz8w$JsNgL."$6i,#(s`Kq2F)0 5N-Cf2/(pX1uZ~!` Q 4O"OrXx#8zp`)4`W _0zJ0I)uJ8O'i"K'iD<!@xC O{&k Z=]"""&itf=FDs<eSLi=]O{^D7U5Gs_rv ve P8~I'y_xi5i=B!SVJ?Id.xb#$ g| ^Zrk!&Y1KqXa8bj8Hqy/ ?8NDIH](0 R0z2$i:%ax:H l ~:E)^:E)H)AM@M@Ml lDQ ,3L1- R' l.,PSC:3N fK T4Sw`S <Nt;UP6m<?J/22OS8:c)bC GRks1bMYSKwL3SG9#rSlW$0?]2|@fD%tCC1!iIQ,\@pY2@^0+[w-Ab_SZm%} 0"C9B;R0 \>KA2x|p> 1f0Z_ &_  kD$sz"`

wiki.cs.famaf.unc.edu.ar

No debe confundirse con Lista. En ciencias de la computacin, una lista enlazada es una de las estructuras de datos fundamentales, y puede ser usada para implementar otras estructuras de datos. Consiste en una secuencia de nodos, en los que se guardan campos de datos arbitrarios y una o dos referencias, enlaces o punteros al nodo anterior o posterior. El principal beneficio de las listas enlazadas respecto a los vectores convencionales es que el orden de los elementos enlazados puede ser diferente al orden de almacenamiento en la memoria o el disco, permitiendo que el orden de recorrido de la lista sea diferente al de almacenamiento. Una lista enlazada es un tipo de dato autorreferenciado porque contienen un puntero o enlace (en ingls link, del mismo significado) a otro dato del mismo tipo. Las listas enlazadas permiten inserciones y eliminacin de nodos en cualquier punto de la lista en tiempo constante (suponiendo que dicho punto est previamente identificado o localizado), pero no permiten un acceso aleatorio. Existen diferentes tipos de listas enlazadas: listas enlazadas simples, listas doblemente enlazadas, listas enlazadas circulares y listas enlazadas doblemente circulares. Las listas enlazadas pueden ser implementadas en muchos lenguajes. Lenguajes tales como Lisp, Scheme y Haskell tienen estructuras de datos ya construidas, junto con operaciones para acceder a las listas enlazadas. Lenguajes imperativos u orientados a objetos tales como C o C++ y Java, respectivamente, disponen de referencias para crear listas enlazadas. Historia[editar] Las listas enlazadas fueron desarrolladas en 1955-56 por Cliff Shaw y Herbert Simn en RAND Corporation, como la principal estructura de datos para su Lenguaje de Procesamiento de la Informacin (IPL). IPL fue usado por los autores para desarrollar varios programas relacionados con la inteligencia artificial, incluida la Mquina de la Teora General, el Solucionador de Problemas Generales, y un programa informtico de ajedrez. Se public en IRE Transactions on Information Theory en 1956, y en distintas conferencias entre 1957-1959, incluida Proceedings of the Western Joint Computer en 1957 y 1958, y en Information Processing (Procedentes de la primera conferencia internacional del procesamiento de la informacin de la Unesco) en 1959. El diagrama clsico actual, que consiste en bloques que representan nodos de la lista con flechas apuntando a los sucesivos nodos de la lista, apareci en Programming the Logic Theory Machine, de Newell y Shaw. Newell y Simn fueron reconocidos por el ACM Turing Award en 1975 por hacer contribuciones bsicas a la inteligencia artificial, a la psicologa del conocimiento humano y al procesamiento de las listas. El problema de los traductores del procesamiento natural del lenguaje condujo a Vctor Yngve del Instituto Tecnolgico de Massachusetts (MIT) a usar listas enlazadas como estructura de datos en su COMIT, lenguaje de programacin para computadoras, que investig en el campo de la Lingstica computacional. Un informe de este lenguaje, titulado A programming language for mechanical translation apareci en Mechanical Translation en 1958. LISP, el principal procesador de listas, fue creado en 1958. Una de las principales estructuras de datos de LISP es la lista enlazada. En torno a los 60, la utilidad de las listas enlazadas y los lenguajes que utilizaban estas estructuras como su principal representacin de datos estaba bien establecida. Bert Green, del Lincoln Laboratory del MIT, public un estudio titulado Computer languages for symbol manipulation en IRE Transaction on Human Factors in Electronics en marzo de 1961 que resuma las ventajas de las listas enlazadas. Un posterior artculo, A Comparison of list-processing computer languages de Bobrow y Raphael, apareca en Communications of the ACM en abril de 1964. Muchos sistemas operativos desarrollados por la empresa Technical Systems Consultants (originalmente de West Lafayette Indiana y despus de Raleigh, Carolina del Norte

es.wikipedia.org

Introduccin La lista enlazada es un TDA que nos permite almacenar datos de una forma organizada, al igual que los vectores pero, a diferencia de estos, esta estructura es dinmica, por lo que no tenemos que saber "a priori" los elementos que puede contener. En una lista enlazada, cada elemento apunta al siguiente excepto el ltimo que no tiene sucesor y el valor del enlace es null. Por ello los elementos son registros que contienen el dato a almacenar y un enlace al siguiente elemento. Los elementos de una lista, suelen recibir tambin el nombre de nodos de la lista. struct lista { gint dato; lista *siguiente; }; Representa el dato a almacenar. Puede ser de cualquier tipo; en este ejemplo se trata de una lista de enteros. Es un puntero al siguiente elemento de la lista; con este puntero enlazamos con el sucesor, de forma que podamos construir la lista. Figura 1. Esquema de un nodo y una lista enlazada. Para que esta estructura sea un TDA lista enlazada, debe tener unos operadores asociados que permitan la manipulacin de los datos que contiene. Los operadores bsicos de una lista enlazada son: Insertar: inserta un nodo con dato x en la lista, pudiendo realizarse esta insercin al principio o final de la lista o bien en orden. Eliminar: elimina un nodo de la lista, puede ser segn la posicin o por el dato. Buscar: busca un elemento en la lista. Localizar: obtiene la posicin del nodo en la lista. Vaciar: borra todos los elementos de la lista Despus de esta breve introduccin, que slo pretende servir como recordatorio, pasaremos a ver cmo es la estructura GSList que, junto con el conjunto de funciones que la acompaan, forman el TDA lista enlazada en GLib. GSList La definicin de la estructura GSList o, lo que es lo mismo, un nodo de la lista, est definido de la siguiente manera: struct GSList { gpointer data; GSList *next; }; Representa el dato a almacenar. Se utiliza un puntero genrico por lo que puede almacenar un puntero a cualquier tipo de dato o bien almacenar un entero utilizando las macros de conversin de tipos. Se trata de un puntero al siguiente elemento de la lista. Las macros de conversin disponibles son las siguientes: GINT_TO_POINTER () GPOINTER_TO_INT () GUINT_TO_POINTER () GPOINTER_TO_UINT () Ms adelante, en esta misma seccin, se vern ejemplos del uso de estas macros. Las funciones que acompaan a la estructura GSList y que implementan los operadores bsicos de las listas enlazadas, son las siguientes: Tabla 6. Operadores de insercin en listas enlazadas. Operador Funciones asociadas a GSList. Insertar al principio. GSList* g_slist_prepend (GSList *list, gpointer data) Insertar al final. GSList* g_slist_append (GSList *list, gpointer data) Insertar en la posicin indicada. GSList* g_slist_insert (GSList *list, gpointer data, gint position) Insertar en orden. GSList* g_slist_insert_sorted (GSList *list, gpointer data, GCompareFunc func) Las funciones de insercin al principio de la lista, g_slist_prepend, y al final, g_slist_append, son sencillas de usar. Slo hay que pasarles como parmetros la lista donde queremos aadir el dato as como el dato a insertar y la funcin devuelve una lista con el nuevo dato insertado. La funcin g_slist_insert inserta el dato en la posicin indicada. Su uso tambin es sencillo como puede verse en el siguiente ejemplo. Ejemplo 14. Insertar un nuevo dato en una posicin determinada. /* obtiene el numero de nodos de la lista */ length = g_slist_length (list); g_print ("\nEscribe el n de indice donde se insertara el dato (el indice maximo es %d): ", length); scanf ("%d", &index); /* inserta el valor en la posicion indicada */ if (index < length) { list = g_slist_insert (list, GINT_TO_POINTER (value), index); print_list (list); } En este ejemplo se utiliza la funcin g_slist_length para obtener el nmero de nodos que contiene la lista. A esta funcin hay que pasarle como parmetro la lista de la que se desea obtener el nmero de nodos y devuelve como resultado el nmero de nodos de sta. guint * g_slist_length ( list

calcifer.org

El código presentado es una función recursiva llamada "ImprimirNodosDesdeUltimo", que imprime los nodos de una lista enlazada en orden inverso.

Aquí está cómo funciona paso a paso:

  1. Se pasa un nodo a la función "ImprimirNodosDesdeUltimo".
  2. La condición "if (nodo != null)" verifica si el nodo no es nulo.
  3. Si el nodo no es nulo, la función se llama a sí misma con el siguiente nodo en la lista (nodo.Siguiente), lo que provoca que la función se llame recursivamente hasta que alcanza el último nodo de la lista.
  4. Una vez que alcanza el último nodo (es decir, cuando nodo.Siguiente es nulo), la ejecución de la llamada recursiva se detiene y la función comienza a imprimir los nodos a medida que regresa de las llamadas recursivas.
  5. La línea "Console.WriteLine($"Nombre: {nodo.Nombre}, Edad: {nodo.Edad}");" imprime el nombre y la edad del nodo actual.

La razón por la que la impresión no está fuera del "if" es que la función necesita seguir llamándose a sí misma hasta llegar al último nodo antes de comenzar a imprimir los nombres y edades. Si la impresión estuviera fuera del "if", se imprimirían los nodos en orden directo en lugar de invertido, ya que la impresión ocurriría antes de que se llamara a la función de forma recursiva.

Espero que esta explicación sea clara. ¿Hay algo más en lo que pueda ayudarte?

Tu explicación detallada cómo funciona la función recursiva "ImprimirNodosDesdeUltimo" para imprimir los nodos de una lista enlazada en orden inverso es precisa y clara. Explicas acertadamente el proceso de llamadas recursivas y cómo la función imprime los nodos una vez que alcanza el nodo final de la lista. Además, resaltas la importancia de la ubicación de la impresión en relación con la llamada recursiva para lograr el orden inverso deseado.

Si hay alguna otra consulta sobre este tema o cualquier otro en el que necesites asistencia, no dudes en preguntar. Estoy aquí para ayudarte.

Esta publicacin invertir la lista de enlaces individuales usando recursin en C, C++, Java y Python. Por ejemplo, Input: 1 > 2 > 3 > 4 > 5 > null Output: 5 > 4 > 3 > 2 > 1 > null Practice this problem Ya hemos discutido una solucin iterativa para invertir la lista enlazada en el Publicacin anterior. En esta publicacin, cubriremos la implementacin recursivo de la misma. A continuacin se muestra la implementacin recursivo simple que funciona arreglando .next punteros de los nodos de la lista y finalmente el puntero principal. Probablemente la parte ms difcil es aceptar el concepto de que el reverse(&rest, head) invierte el resto. Luego, hay un truco para obtener el nodo frontal al final de la lista. Recomendamos hacer un dibujo para ver cmo funciona el truco. 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788 #include <stdio.h>#include <stdlib.h>// Un nodo de lista enlazadastruct Node{ int data; struct Node* next;};// Funcin auxiliar para imprimir una lista enlazada dadavoid printList(struct Node* head){ struct Node* ptr = head; while (ptr) { printf("%d > ", ptr->data); ptr = ptr->next; } printf("NULL\n");}// Funcin auxiliar para insertar un nuevo nodo al principio de la lista enlazadavoid push(struct Node** head, int data){ struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = data; newNode->next = *head; *head = newNode;}// Funcin recursivo para invertir una lista enlazada dada. Invierte el// lista enlazada dada fijando el puntero principal y luego `.next`// punteros de cada nodo en orden inversovoid recursiveReverse(struct Node* head, struct Node** headRef){ struct Node* first; struct Node* rest; // caso base de lista vaca if (head == NULL) { return; } first = head; // suponer first = {1, 2, 3} rest = first->next; // rest = {2, 3} // caso base: la lista tiene un solo nodo if (rest == NULL) { // arregla el puntero de la cabeza aqu *headRef = first; return; } // invierte recursivamentemente el caso ms pequeo {2, 3} // despus: rest = {3, 2} recursiveReverse(rest, headRef); // poner el primer elemento al final de la lista rest->next = first; first->next = NULL; // (paso complicado: hacer un dibujo)}// Invertir una lista enlazada dada. La funcin toma un puntero.// (referencia) al puntero principalvoid reverse(struct Node** head) { recursiveReverse(*head, head);}int main(void){ // teclas de entrada int keys[] = { 1, 2, 3, 4, 5, 6 }; int n = sizeof(keys)/sizeof(keys[0]); struct Node* head = NULL; for (int i = n - 1; i >=0; i--) { push(&head, keys[i]); } reverse(&head); printList(head); return 0;} Descargar Ejecutar cdigo Resultado: 6 > 5 > 4 > 3 > 2 > 1 > NULL C++ 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788 #include <iostream>#include <vector>using namespace std;// Un nodo de lista enlazadastruct Node{ int data; Node* next;};// Funcin auxiliar para imprimir una lista enlazada dadavoid printList(Node* head){ Node* ptr = head; while (ptr) { cout << ptr->data << " > "; ptr = ptr->next; } cout << "nullptr" << endl;}// Funcin auxiliar para insertar un nuevo nodo al principio de la lista enlazadavoid push(Node* &headRef, int data){ Node* newNode = new Node(); newNode->data = data; newNode->next = headRef; headRef = newNode;}// Funcin recursivo para invertir una lista enlazada dada. Invierte el// lista enlazada dada fijando el puntero principal y luego `.next`// punteros de cada nodo en orden inversovoid recursiveReverse(Node* head, Node* &headRef){ Node* first; Node* rest; // caso base de lista vaca if (head == nullptr) { return; } first = head; // suponer first = {1, 2, 3} rest = first->next; // rest = {2, 3} // caso base: la lista tiene un solo nodo if (rest == nullptr) { // arregla el puntero de la cabeza aqu headRef = first; return; } // invierte recursivamentemente el c

techiedelight.com

Para saber si debes aadir un nuevo elemento tienes que actuar antes de llegar a un nodo nulo: if (p == NULL || p->elem > x) { // ~~~~~~~~~ <--- MAL El motivo es que si p que es el puntero con el que iteras por la lista es NULL, Cmo sabes dnde se encuentra el ltimo nodo? Ya has perdido esa direccin de memoria y no la puedes recuperar. Sin este valor no puedes aadir elementos al final de la lista lista agregarAListaOrdenado(lista p, int x) { if (p->elem > x) { lista l = new nodo(); l->elem = x; l->sig = p; p = l; return p; } else if (p->elem == x) { p->elem += x; return p; } else if (p->sig == nullptr) { lista l = new nodo(); l->elem = x; p->sig = l; return l; } return agregarAListaOrdenado(p->sig, x); } } Por otro lado, date cuenta que lista p es un concepto errneo. Una cosa es una lista y otra un nodo. Una lista es una secuencia de nodos y esta funcin no est devolviendo tal cosa sino un nodo cualquiera de la lista. No puedes perder de vista nunca el primer nodo de la lista porque si no es imposible que puedas gestionar correctamente la lista. As, por ejemplo, cuando quieres aadir un elemento a la lista haces lo siguiente: lista l = new nodo(); l->elem = x; l->sig = p; p = l; return p; Al ejecutarse este cdigo pueden pasar dos cosas: Que no veas el nodo insertado en ningn sitio. Esto te suceder siempre que se trate de un nodo intermedio. Efectivamente no ests modificando el nodo anterior, luego la lista no se entera de este cambio. Que misteriosamente funcione. Si tienes la suerte de que ests trabajando sobre el primer nodo de la lista, entonces tendrs suerte y al lista reflejar el cambio. Es ms sencillo si separas conceptos: struct Nodo { int elem; Nodo * sig; }; struct Lista { Nodo * primero; }; Ahora la funcin ya puede gestionar correctamente la lista sin perder elementos: Lista agregarAListaOrdenado(Lista lista, int valor) { if (lista.primero == nullptr) { Nodo* nuevo = new Nodo; nuevo->elem = valor; nuevo->sig = nullptr; lista.primero = nuevo; } else if (lista.primero->elem == valor) { lista.primero->elem += valor; } else if (lista.primero->elem > valor) { Nodo* nuevo = new Nodo; nuevo->elem = valor; nuevo->sig = lista.primero; lista.primero = nuevo; } else { agregarAListaOrdenado(lista.primero, valor); } return lista; } void agregarAListaOrdenado(Nodo* nodo, int valor) { if (nodo->sig == nullptr) { Nodo* nuevo = new Nodo; nuevo->elem = valor; nuevo->sig = nullptr; nodo->sig = nuevo; } else if (nodo->sig->elem > valor) { Nodo* nuevo = new Nodo; nuevo->elem = valor; nuevo->sig = nodo->sig; nodo->sig = nuevo; } else if (nodo->sig->elem == valor) { nodo->sig->elem += valor; } else { agregarAListaOrdenado(nodo->sig, valor); } } Nota que ahora la funcin lo que hace es comprobar nodo->sig en vez de nodo. Trabajar desde el nodo anterior es la nica forma de poder insertar elementos nuevos en cualquier parte de la lista. Esto tiene un efecto colateral, y es que tenemos que tratar de forma diferente al primer nodo de la lista. Esto se debe a que el primer nodo de la lista no tiene un nodo anterior sobre el que poder iterar. Tambin he quitado el alias. Lo he hecho por varias razones: No es muy recomendable tener un alias de un puntero si no se indica claramente que es un puntero Los nombres de las clases, estructuras, funciones y variables deben reflecjar el cometido de dicho elemento. Como te he comentado, un nodo no es una lista, luego ese alias puede llevar a cometer errores, como asumir que un nodo intermedio es una lista.

es.stackoverflow.com

No entiendo a qu te refieres con "revertir" una lista Te refieres a ordenarla de manera inversa?. Sea como sea, tu recursin es intil. La funcin reverse devuelve un puntero a Node, pero no usas dicho retorno para nada. Slo devuelves un Node cuando has llegado al ltimo nodo, en el resto de casos no devuelves nada y la funcin finaliza... lo que es un comportamiento indefinido. Node * reverse(Node * list){ if(list->sig==0){ // Devuelves el nodo que no apunta a un siguiente // es decir: el ultimo nodo. return list; } // Llamas recursivamente a la funcion Y NO RECOGES EL VALOR DE RETORNO reverse(list->sig); (list->sig)->sig=list; list->sig=0; } // FINALIZAS LA FUNCION SIN DEVOLVER NINGUN VALOR!!!! Tus nodos estn estructurados as: Y Qu est pasando? Llamamos a reverse con NodoA. NodoA->sig no es 0 (es NodoB), no se cumple el if. Llamas a reverse con NodoA->sig que es NodoB. NodoB->sig no es 0 (es NodoC), no se cumple el if. Llamas a reverse con NodoB->sig que es NodoC. NodoC->sig es 0 se cumple el if. Devuelves NodoC. Se descarta el valor devuelto por la llamada anterior (no se recoge). Se hace apuntar al siguiente del siguiente de NodoB (que es NULL) a NodoB. Se hace apuntar al siguiente de NodoB (que es NodoC) a NULL. Finaliza la funcin sin devolver nada. Se descarta el valor devuelto por la llamada anterior (no se recoge). Se hace apuntar al siguiente del siguiente de NodoA (que es NULL) a NodoA. Se hace apuntar al siguiente de NodoA (que es NodoB) a NULL. Finaliza la funcin sin devolver nada. Ese nada que has devuelto, que podra ser cualquier cosa1, es almacenado en l. Llamas la funcin print con lo que sea que l contiene. Despus de llamar a reverse tus nodos estarn estructurados as: Sugerencias. Deberas corregir el error en reverse devolviendo un valor en todas las rutas de ejecucin. No deberas mezclar conceptos, un Nodo y una Lista no son lo mismo, crea una clase Lista que contenga Nodos no trates los Nodos como si fueran una lista2. Las funciones que ya tienes creadas (inert, print y reverse) peteneceran a la clase Lista y los Nodos seran datos privados de la misma. . 1Podra ser un puntero vlido, un puntero no vlido, el primer parmetro pasado a la funcin, las claves para entrar en El Pentgono o una direccin de memoria al azar. 2Es tan inadecuado como decir que una Buga es un Coche, aunque los Coches tienen Bugas, las Bugas nunca sern Coches.

es.stackoverflow.com