Mensajes

[list->next = node]

No se puede hacer list->next = node porqué node es solo un puntero y no tiene dato.
En la práctica es esto:

Código (c) [Seleccionar] Expandir


int* pint = malloc((sizeof(int));
int* node;

node = pint;



Cuándo haces node = list ya creas la relación. node es list.

A ver si me se explicar ahora:
node es una variable puntero auxiliar. Su única función es, junto al while, encontrar el último nodo de la lista.
La variable list no se toca, es el inicio de la lista, lo que hay que regresar. Pero la lista sí que se ha modificado, ha crecido en un elemento.

node = list; es porqué la lista es un dato dinámico y no sabemos que extensión tiene pero sabemos que list, al menos, tiene un nodo válido y que ése es el primero; por tanto hay que empezar a buscar el último nodo de la lista por el primero y recorrerla hasta llegar al final.

A ver si me salen los dibujitos esquemáticos:

Código [Seleccionar] Expandir



XXXXXXXXX <- Esto es nuestra lista

y como toda lista enlazada tiene un puntero apuntando a su cabeza

list
v
XXXXXXXXX



Y <- elemento nuevo que se debe colocar a la lista

como list no se puede tocar, que es lo que hay que regresar nos inventamos node

list
v
XXXXXXXXX      <- esto es node = list
^
node


Y <- por simplicidad lo dejaré perdido por el limbo hasta que lo coloque

ahora node debe encontrar el último elemento

list
v
XXXXXXXXX
^
node

list
v
XXXXXXXXX
 ^
 node

list
v
XXXXXXXXX
  ^
  node

...

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


node, ya no me sirve y lo dejo tranquilo. Desaparecerá cuándo desaparezca la función ya que es una variable local.

La lista se queda ya que es algo que hay en el motón y por tanto permanente.

Debo retornar list porqué apunta a la lista modificada.

Ahora me puedes decir: pero si list tiene la misma posición de memoria al principio de la función que al final, no se ha modificado en nada el valor que guarda, no hace falta devolverla.

Y te digo: sí que hace falta porqué también sirve la función para generar la lista desde cero. Si se le pasa list=NULL a la función ocurre lo siguiente:

Código [Seleccionar] Expandir



list
v
NULL

genero un dato

list
v
NULL

X <- el dato

y enlazo list con el dato

list
v
X



Ahora si no devuelvo list fuera de la función no existiría esta modificación.

Cuándo te decía enseñarle quería decir que debes programar todos los pasos.
Debes escribir las instrucciones necesarias para que cuándo el valor de los segundos lleguen a 60 se pongan a 0 y sumen 1 a los minutos; cuándo los minutos lleguen a 60 se pongan a 0 y sumen 1 a las horas; y que cuándo las horas lleguen a 24 se pongan a 0.
Veo que has visto los ifs, pues puedes hacerlo con esas instrucciones. Si has visto funciones más fácil lo tendrás aún.

El sistema numérico de un ordenador no es sexagesimal por lo que no se pondrá a 0 cuándo llegue la cuenta a 60. Tampoco sabe que 60 segundos son un minuto. Todo eso tendrás que enseñárselo.

Por cierto: no puedes Horas no pueden ser 24, ni los minutos ni los segundos pueden ser 60.

[node = slist_next(node)]

La premisa para que funcione la función es que la lista siempre debe estar terminada con NULL. Si está vacía debe estar apuntando a NULL.

La función pondrá el nodo generado con el dato al final de la lista. Siguiendo la primera premisa éste último nodo debe apuntar a NULL en next.

Lo que se hace es:
Se genera un nodo a partir de la información dada por data.

Si la lista está vacía, NULL, pasará a apuntar al nodo nuevo.
Si la lista no está vacía hay que recorrerla hasta encontrar el último elemento (aquel que apunte a NULL), cambiar el valor next para que apunte al nuevo nodo generado y regresar la lista entera, eso es el primer elemento (list).

Lo que ves en

Código (c) [Seleccionar] Expandir


while (slist_next(node) != slist_nil()) {
    node = slist_next(node);
es precisamente ese recorrido. node apunta al principio de la lista (list) y vamos a trabajar sobre node. Mientras el elemento next de node no sea NULL, node apuntará a node->next (en el código esto está encapsulado por node = slist_next(node). Una vez llegado a éste último elemento la orden list_next(node) = newNode; coloca el nuevo nodo al final de la lista.
Como el inicio de la lista no ha sido modificado (list) y hay que regresar un puntero, precisamente al inicio de la lista, devolvemos list.

Otra versión sin estas macros es así:

Código (c) [Seleccionar] Expandir


SList slist_append(SList list, int data) {
    Slist node;
    SList newNode = malloc(sizeof(SNode));
   
    newNode->data = data;
    newNode->next = NULL;

    if(list == NULL)
        return newNode;

    node = list;

    while(node->next != NULL)
        node = node->next;

    node->next = newNode;

    return list;
}

Busca correspondencia 1 a 1 hasta la longitud que especifiques, en ese sentido busca una subcandena; de acuerdo con todo lo demás.

Eso es strncmp 

strcmp busca una correspondencia 1 a 1 entre las dos cadenas por tanto

• ¿Hay diferencias de capitalización entre las dos cadenas?
• ¿Usas una família gets por un lado y scanf por otro? (las famílias fgets guardan el '\n', scanf no lo guarda)
• Cuándo guardas los nicks en main, o donde sea, ¿estás seguro que no quedan carácteres en el buffer de entrada y se los pasas a la siguiente cadena cuándo vuelves a pedir datos?

Bien, veo que lo has escrito deprisa y corriendo. Para otra vez formatea el código, se agradece verlo bien presentado.

Dentro del bucle do-while, pon la primera instrucción que lleve control a 0. Si hay algún fallo control empezará el bucle ya con código de error y no saldrás de él.

Para scanf, debes hacer que acepte un máximo de 4 caracteres, sino podrías crear desbordamiento de la variable resp. Sobre la variable resp, ella misma ya actúa como puntero y no debes pasarle la dirección de memoria.

No uses fflush(stdin) no es estándar y no va bien con todos los compiladores. Hay alternativas con funciones de librería y un poco de código.

resp<'0'&& resp>'9' puedes sustituirlo por la función de librería isdigit de ctype.h

En el 'case 0' has escrito, en su última instrucción control==1, una comparación sin efecto. Supongo que querías hacer una asignación.

La funciones lo que hacen es devolver el inicio de la lista modificada.
Le entregas la lista y la modificación y la función te la devuelve modificada.

Si quieres que sea más específico deberás decirme exactamente que es que no entiendes.

Está bien lo de la optimización, pero te has saltado lo de que el usuario entra la coordenada de donde quiere el 0. Si lo pone en una esquina no puede haber espejos y el máximo valor del recuadro es 10.