Lo que yo no entiendo es este paso:


Ya sé que el next de node es el ÚLTIMO elemento ya sé eso, pero no sé como lo enlaza capaz no entendí bien la definición de las estructuras o sea yo tenía entendido que se debe poner CUAL ES EL SIGUIENTE elemento.

Es decir uno define node y busca hasta el último elemento y luego lo enlaza con newNode PERFECTO! ESO SE ENTIENDE.

La pregunta es: ¿cuando enlaza list con node? capaz hay algo de la defición que no entiendo

O sea para mi falta un list->next=node; ¿me entendés?
Así como hace node->next=newNode;

¿Por qué no hace falta enlazar de algún modo list con node? yo lo estoy pensando mal y lo sé pero es por alguna estructura o algo que no entendí

Me explicaste todo lo que yo ya sabía, se como trabaja la función se lo que hace, pero no entiendo como la enlaza o sea como relaciona list con node, eso es lo que no entiendo.

O sea como que yo modifico node y también se modifica list si nunca lo relacioné sólo dije node = list (pero acá no estoy cambiando ningún valor de list) y nada más.


ENTIENDO TODO LO QUE HACE LA FUNCIÓN, LO QUE NO ENTIENDO ES PORQUE RETORNA LIST SI NUNCA LO TOCA SI NUNCA LO MODIFICA A LIST, NUNCA DICE "EL SIGUIENTE ELEMENTO DE LIST APUNTA AL NODE"

 
SList slist_append(SList list, int data)
{
      SList newNode = malloc(sizeof(SNode));
      SList node;
      slist_data(newNode) = data;
      slist_next(newNode) = NULL;
      if (list == slist_nil()) {
         return newNode;
      }
      node = list;
      while (slist_next(node) != slist_nil()) {
            node = slist_next(node);
      }
      /* ahora 'node' apunta al ultimo nodo en la lista */
      slist_next(node) = newNode;
      return list;
}
 

Ya sé que el objetivo de la funcón es que devuelva la lista modificada pero no entiendo adónde la modifica, si no toca a list.
A la lista original (list) nunca lo toca, lo único que hace es decir que node = list y de ahí trabaja con node, pisa todos los datos que hay en node (por el node = slist_next(node)), por eso para mí falta algo como slist_next(list)=node;

No logro entender la lógica del código, no sé donde la modifica a lista, para mi esta devolviendo la misma lista que se le pasó sin modificación alguna.

¿Cómo que un puntero al dato modificado si los dos tienen el mismo tipo!?

Último ejercicio que me queda sigo intentando pero pregunto por si las dudas después me quedo trabado

Suponga que está implementando una lista doblemente enlazada. Si en lugar de guardar punteros a los nodos previo y siguiente, guarda un xor de ambos punteros: ¿puede recorrer la lista en ambas direcciones ¿Cómo? Defina en C la estructura correspondiente, ¿qué problemas puede encontrar?

Es lo último, denme una mano en esta.

Saludos!

AlbertoBSD, puedes escribir un troso de código o algún ejemplo así me queda un poco más claro para guiarme no digo que lo hagas es que estoy medio perdido.
Encima el Viernes de la semana que viene rindo, pero llego bien si entiendo esto.

Esta es la implementación ahora te leo MAFUS xD

typedef struct _SNode {
        int    data;
        struct _SNode *next;
} SNode;
 
typedef SNode *SList;
 
#define slist_data(l)       (l)->data
#define slist_next(l)       (l)->next
#define slist_nil()         NULL
 

#include <stdlib.h>
#include "SList.h"
 
SList slist_append(SList list, int data)
{
      SList newNode = malloc(sizeof(SNode));
      SList node;
      slist_data(newNode) = data;
      slist_next(newNode) = NULL;
      if (list == slist_nil()) {
         return newNode;
      }
      node = list;
      while (slist_next(node) != slist_nil()) {
            node = slist_next(node);
      }
      /* ahora 'node' apunta al ultimo nodo en la lista */
      slist_next(node) = newNode;
      return list;
}
 
SList slist_prepend(SList list, int data)
{
      SList newNode = malloc(sizeof(SNode));
      slist_next(newNode) = list;
      slist_data(newNode) = data;
      return newNode;
}
 
void  slist_destroy(SList list)
{
      SList nodeToDelete;
 
      while (list != slist_nil()) {
            nodeToDelete = list;
            list = slist_next(list);
            free(nodeToDelete);
      }
}
 
void  slist_foreach(SList list, VisitorFuncInt visit, void *extra_data)
{
      SList node = list;
 
      while (node != slist_nil()) {
            visit(slist_data(node), extra_data);
            node = slist_next(node);
      }
}
 

Tengo un lío de tipos en la cabeza. ¿Por qué regresa un puntero si los dos están declarados de la misma forma AAAHHHH WTFF !! ?



No te entiendo bien, pero no creo ¿por qué así?
Yo sólo pregunté por qué retorna node jaja tengo más confusión ahora.
 

Las listas enlazadas implementadas con punteros tienen la flexibilidad de poder insertar elementos en cualquier parte de ellas sin mover los elementos anteriores ni posteriores, mientras que los arreglos no cuentan con esta flexibilidad.
Proponga una implementación de similar a listas enlazadas, pero de longitud fija, utilizando arreglos, y que provea esta flexibilidad.

Me maté pensandolo pero no me sale, no tengo alguna idea para empezar, ¿alguien que me pueda encaminar?, por favor.

---

Y tengo otra duda con un problema de tipos que tengo en mi cabeza al parecer(no tiene nada que ver con el anterior ejercicio):

SList slist_append(SList list, int data)
{
      SList newNode = malloc(sizeof(SNode));
      SList node;
      slist_data(newNode) = data;
      slist_next(newNode) = NULL;
      if (list == slist_nil()) {
         return newNode;
      }
      node = list;
      while (slist_next(node) != slist_nil()) {
            node = slist_next(node);
      }
      /* ahora 'node' apunta al ultimo nodo en la lista */
      slist_next(node) = newNode;
      return list;
}
 

¿Por qué retorna list, no sería node?
Si yo estoy trabajando con node y no con list, a list ni siquiera lo he tocado es porque es algún puntero o algo así?

No lo entiendo

Saludos!

Exacto*
Listo duda aclarada, no hace falta utilizar un debugger simplemente puedes hacer un printf con "%p" como decía MAFUS.

Gracias a los dos
Saludos!

Y si es de sólo lectura, ¿por qué este código sí funciona?

#include <stdio.h>
 
int main (void){
 
        char s[]="Aloja";
        char *z="Aloja";
 
 
        s[0]='H';
        s[1]='o';
        s[2]='l';
        s[3]='a';
        s[4]='0';
 
        z="POR QUE FUNCIONA";
 
        // s=&s[0]
 
        printf ("s:%s\n",s);
        printf ("z:%s\n",z);
 
        return 0;
}
 

O sea a lo que te referís es que yo no puedo hacer esto: z[0]='X' no?

¿Eso funciona porque lo que hace el compilador es guardar una nueva cadena en la memoria y cambiar la direccion del puntero o algo así?

¿Es lo mismo hacer esto?

#include <stdio.h>
#include <stdlib.h>
 
int main (void){
 
        char *s;
        s=(char *) malloc (3);
 
        s[0]='1';
        s[1]='2';
        s[2]='3';
 
 
        printf ("%s\n",s);
 
        return 0;
}
 

Que

#include <stdio.h>
 
int main (void){
 
        char s[3];
 
        char s[0]='1';
        char s[1]='2';
        char s[2]='3';
 
        printf ("%s\n",s);
 
}
 

¿Podría hacer lo mismo utilizando char * pero sin utilizar malloc?

Otra duda

char *s="aloja"; char s[]="aloja"; 

¿Qué diferencias tienen?

Saludos!