Mensajes

Bueno aquí te dejo este pdf de mi facultad:

http://www.dc.fi.udc.es/~so-grado/CursoC.pdf

No es gran cosa, pero hay algún que otro tema bastante interesante como punteros y arrays multidimensionales, y está en español.

Eso sí es para iniciarse.

[PERDERÁS LA REFERENCIA A LA LISTA]

Código (c) [Seleccionar] Expandir

void insert(LISTNODEPTR *sPtr, char value)
{
    LISTNODEPTR newPtr, previewPtr, currentPtr;

    newPtr = malloc(sizeof(LISTNODE));

    if (newPtr != NULL) {
               newPtr->data = value;
               newPtr->nextPtr = NULL;

               previousPtr = NULL;
               currentPtr = *sPtr;

               while (currentPtr != NULL && value > currentPtr->data) {
                     previousPtr = currentPtr;
                     currentPtr = currentPtr->nextPtr;
               }

               if (previousPtr == NULL) {
                              newPtr->nextPtr = *sPtr; //¿Para que es esta linea?, si sPtr se usa por primera ves con NULL, entonces aqui newPTr.nextPtr valdra NULL?
                              *sPtr = newPtr; // Como es esta linea no entiendo
               }
               else {
                    previousPtr->nextPtr = newPtr; // Para que es esto?
                    newPtr->nextPtr = currentPtr; // y Esto para que se hace? una explicacion detallada por favor
               }
    }
    else
        printf("%c not inserted. No memory available.\n", value);
}

La idea es tener una lista simplemente ordenada y esa función inserta ordenadamente.

*sPtr no es NULO. *sPtr es un puntero a un nodo que se pasa a la función. En general sería el puntero al primer nodo de la lista, es decir el puntero cabecera. Si fuera NULO, la lista estaría vacía. Hay listas que se implementan de manera que al crear la lista ya añadas un Nodo. Todo depende de la implementación que se siga.

Luego verificas si hay memoria, creas el nodo y lo inicializas tatatata...

Con el while recorres la lista enlazada y este ciclo terminará cuando el puntero siguiente de un nodo actual apunte a NULO o también cuando el valor que quieras insertar sea mayor que el valor del nodo actual.

Si previousPtr está a NULL al salir del bucle es que la lista está vacía o hay que insertar en la primera posición.

Código (c) [Seleccionar] Expandir

newPtr->nextPtr = *sPtr;
*sPtr = newPtr;

Verás que sencillo es de enteder.

Si la lista está vacía, *sPtr será NULO y el siguiente del nodo creado apuntará a NULO. Luego hacemos que el puntero cabecera de la lista *sPtr apunte al nuevo nodo creado de tal manera que habrás insertado un nodo en una lista vacía.

*sPtr----->[newPtr]----->NULO

En el caso de que haya uno o más elementos. Imagina que haces *sPtr = newPtr;. En este caso PERDERÁS LA REFERENCIA A LA LISTA y habrás estropeado tu estructura. Entonces al hacer primero newPtr->nextPtr = *sPtr; te aseguras de que el nuevo nodo creado apunte a la cabeza de la lista y luego tú puedas apuntar con *sPtr a newPtr de tal manera que no perderás la referencia a la lista e insertarás en la primera posición:

Inicialmente: *sPtr----->[newPtr]----->[newPtr2]----->[newPtr3]----->[newPtr4]----->[newPtrN]----->NULO

Hacemos: newPtr->nextPtr = *sPtr;

Entonces: newPtr->nextPtr----->[newPtr]----->[newPtr2]----->[newPtr3]----->[newPtr4]----->[newPtrN]----->NULO

Y finalmente hacemos *sPtr = newPtr;

Entonces: *sPtr----->newPtr->nextPtr----->[newPtr]----->[newPtr2]----->[newPtr3]----->[newPtr4]----->[newPtrN]----->NULO



Por último como previousPtr no es nulo pues haces una inserción en el medio de la lista o al final.

Código (c) [Seleccionar] Expandir

previousPtr->nextPtr = newPtr;
newPtr->nextPtr = currentPtr;

Entonces ahora piensa que tienes que insertar por el medio, tendrás un nodo "anterior" y un nodo "posterior"

Entonces la idea es: [NodoAnterior]------>[NuevoNodoAInsertar]------>[NodoPosterior]

Entonces: previousPtr->nextPtr = newPtr; <= Es la unión NodoAnterior ------> NuevoNodoAInsertar

y newPtr->nextPtr = currentPtr; <= Es la unión NuevoNodoAInsertar ------> NodoPosterior


Por último si insertas al final.

La idea es: [UltimoNodo]------>[NuevoNodoAInsertar]------>NULO <= En este caso currentPtr sería NULO en vez de tener una referencia a un nodo interno distinta del primer nodo.

En la función del delete es necesario usar:

Código (c) [Seleccionar] Expandir

(*sPtr)->data

La función recibe un LISTNODEPTR *sPtr, por tanto deberás usar *sPtr dentro de la función

Por otra parte, el operador de indirección -> tiene prioridad sobre el operador *, por lo que si no pones paréntesis, esa línea será tomada como:

Código (c) [Seleccionar] Expandir

*(sPtr->data)

Y eso no tienen ningún sentido. En cambio:

Código (c) [Seleccionar] Expandir

(*sPtr)->data

Sí que tiene porque con (*sPtr) haces referencia a ese puntero y luego con -> data accedes al campo data de la struct Nodo apuntada por el puntero *sPtr.

Perdón si te lío pero esa es la explicación.

¡Saludos!

fgets() también te puede servir y es la que suelo utilizar.

http://www.cplusplus.com/reference/clibrary/cstdio/fgets/

Si quieres formatear tu disco local debes hacerlo sin estar usando esa unidad o la partición que corresponda a esa unidad. Por tanto deberías usar un dispositivo externo para hacerlo o si tienes una partición con un sistema operativo, hacerlo desde ahí.

Pero si no pones 0, el programa no termina, y lo que esta tratando de buscar eaguel es que el programa se cierre.

Sera una redundancia, pero si pones return mes el programa no se cierra, y el return 0 esta puesto para que se cierre si introduces el numero 0, lo que no entiendo es lo de la bifurcacion, el return 0 solo se ejecutara si introduces el numero 0, y despues el otro return 0 si la ejecucion del programa es correcta, no hay mas.

Saludos

Disculpa, eso pasa cuando no lees los códigos xD.

Otra cosa, el do while va a terminar cuando mes sea igual a 0... Pero dentro de ese ciclo tienes otro ciclo que verifique que introduces números entre 1 y 12 para mes... Nunca va a terminar...

Código (c) [Seleccionar] Expandir

while (mes < ENERO || mes > DICIEMBRE) {..}

Ahí pides un número entre 1 y 12 para mes... Por tanto al llegar al final del do while, mes nunca será 0.

Si lo colocas así ya va a funcionar como quieres:

Código (c) [Seleccionar] Expandir

while ((mes < ENERO-1) || mes > DICIEMBRE) {..}

[exactamente]

Excelente la ayuda de todos! Muy agradecido! Jamas hubiese llegado a esas resoluciones! Soy mas iterativo!!!

Mil gracias!

Ya que te quedaste sorprendido haz méritos para que tú mismo puedas llegar a esas soluciones. La clave es programar, no hay otra clave mayor que esa. Programar, programar, programar y programar, tratando de resolver diferentes problemas.

Aunque no llegues al resultado final que debes, el hecho de practicar, investigar, y buscar soluciones te vendrá de perlas, porque aprenderás nuevas ideas, conceptos, técnicas que en un futuro seguro que te servirán. Y además, al forzarte a resolverlos, adquirirás experiencia en la resolución de esos problemas y para el futuro tendrás un abanico mayor de ideas para resolver un determinado problema.

Así que mi consejo es que programes, programes, y programes. Y cuando ya veas que no puedes más, pues expones el ejercicio y tu resolución en el foro, para preguntar o para impresionarnos

Además es muy importante saber lo que estás haciendo en cada momento. Es decir, saber exactamente qué hace el programa en todo momento sin tener que compilarlo.

Te dejo una imagen cómica, aunque es realista: https://pbs.twimg.com/media/A6Xjm5eCYAEubDL.jpg:large

¡Saludos y perdón por mis párrafos!

y como es mas o mnos pues

Si lees todas las respuestas de tu tema verías que te propongo dos soluciones, y otro usuario te recomienda una de ellas por ser más inteligible.

Si, el codigo funciona, el uso de return 0 en medio del programa nose si es correcto, supongo que si, pero el bucle while que contiene return 0, no tiene sentido que sea un bucle, porque esa sentencia termina el programa, entonces solo se ejecutara una vez, lo mas logico seria con un if, cambia esto:

Código (c) [Seleccionar] Expandir

while (mes == 0)
    {
     return 0;
    }

Por esto:

Código (c) [Seleccionar] Expandir

if (mes == 0) return 0;

Saludos

No he leído el código pero además si dentro del while no tuviera una instrucción que modificara la variable de control del bucle, este se iría a infinito. Porque tiene return y termina la ejecución de la función que si no... Catapún xD

Por cierto:

Código (c) [Seleccionar] Expandir

if (mes == 0) return 0;

Es una redundancia, lo lógico sería escribir:

Código (c) [Seleccionar] Expandir

return mes

Por otra parte, dejas el return en una bifurcación, que puede ser tomada o no. Problema avistado xD

¡Saludetes!

He estado entrando últimamente al foro y, concretamente, a este subforo y veo muchísimos códigos que están fuera de la etiqueda [ code ] y lo más irónico es que ni siquiera están identandos (con tabuladores).

Yo, claramente me niego a leer códigos de esas características. Os pido a todos aquellos que no sigáis esa norma o que no estéis acostumbrados a hacerlo, que la tratéis de cumplir. No tan solo porque debéis, sino porque de esa manera atraeréis a más usuarios para que os ayuden.

Es un quid pro cuo, si pides ayuda, trata de facilitar el trabajo

Ahora podéis criticarme, banearme, lapidarme... lo que deseéis. Pero solo deseaba dejar constancia de ese hecho.

Gracias por su atención.

¡Cuadradoooooooooooooo! O_O Será la potencia n-ésima, digo yo.

Solución recursiva terminal (en Pascal xD)

Código (pascal) [Seleccionar] Expandir

function potencia (b,e:integer):integer;
function pot_aux(b,e,contador:integer):integer;
begin
if e=0 then pot_aux := contador
else pot_aux := pot_aux(b,e-1,b*contador);
end;
begin
potencia := pot_aux(b,e,1);
end;

Solución recursiva sin ser terminal (en pseudocódigo)

Código [Seleccionar] Expandir

funcion recursiva potencia2(x,n)
          if n == 0
               return 1
          else
              return x*potencia2(x, n-1)