Mensajes

[list->next=node;]

Lo que yo no entiendo es este paso:

Código [Seleccionar] Expandir


list
v
XXXXXXXXX
       ^
       node

Ahora el next de node, que es exactamente lo mismo al next del último elemento enlaza a Y y virtualmente obtenemos lo siguiente

list
v
XXXXXXXXXY

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_next(list)=node;]

Código (c) [Seleccionar] Expandir


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.

Está pensado para modificar la misma lista que se le pasa, pero en vez de modificar directamente el parámetro list lo que hace es modificarlo y regresar un puntero con el dato modificado. Seguramente el autor pensó en esa solución para dar un valor en caso de que list fuera NULL. Pero hubiera hecho lo mismo con un puntero a puntero y el resultado habría sido más natural.

¿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

Código (c) [Seleccionar] Expandir

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


Código (c) [Seleccionar] Expandir

#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 !! ?

¿Era esto lo que esperaba el autor que se hiciera?

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.

[Proponga una implementación de similar a listas enlazadas, pero de longitud fija, utilizando arreglos, y que provea esta flexibilidad]

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):

Código (c) [Seleccionar] Expandir

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!

Exácto, tambien lo puedes ver en un debugger.

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?

Código (c) [Seleccionar] Expandir


#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í?

[Que]

¿Es lo mismo hacer esto?

Código (c) [Seleccionar] Expandir

#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

Código (c) [Seleccionar] Expandir


#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

Código (c) [Seleccionar] Expandir

char *s="aloja"; char s[]="aloja";
¿Qué diferencias tienen?

Saludos!