programacion en C de listas dinámicas usando punteros

[madness]

Muy buenas noches a todos! he recurrido a esta página con el objetivo de que me puedan ayudar! Soy un estudiante de Ing. en Computación e Informática y me han dado una Tarea en Estructura de Datos donde debo realizar un programa utilizando memoria dinámica y no tengo ningún conocimiento de este tema! solo tengo entendido que la funcion Malloc funciona para este tipo de memorias
Espero que me puedan ayudar ya que no quiero reprobar el ramo ! De ante mano muchas gracias

[Ogramar]

Hola madness ¿pero cuál es el enunciado de la tarea, es decir, qué es lo que tienes que hacer? 

[madness]

Hola Ogramar ! es un poquito grande, mira:

"Realizar una comparacion que contemple un analisis respecto del tamaño de la entrada vs. el tiempo de los algoritmos de ordenamiento. Debe implementar cuatro algoritmos de ordenamiento: dos basicos y dos mas avanzados.

* Debe utilizar los siguientes tamaños de arreglos: 50, 100, 500, 1000, 5000, 10000, 50000, 100000.
* Para la generacion del arreglo de datos debe utilizar memoria dinamica.

Los algoritmos de ordenacion basico son: Seleccion, burbuja e insercion.
Los algoritmos de ordenacion mas avanzados son: Shell, Mergesort, Radixsort, Binsort y Quicksort"

Ayuda por favor

[Ogramar]

Lo primero que vas a necesitar es conocer al menos a nivel básico qué son los punteros en C (supongo que vas a hacerlo en C).

Por ejemplo:

typedef struct ElementoLista {
      int dato;
      struct ElementoLista *siguiente;
}Elemento;

Aquí se está usando un puntero, que es precisamente lo que permite crear una lista enlazada dinámicamente que puede ir agrandándose o acortándose en función de las necesidades.

Teniendo conocimientos básicos sobre punteros tienes que crear las operaciones básicas para operar con la lista: inserción de elementos, borrado de elementos, etc. y para eso te hace falta la asignación dinámica de memoria

Finalmente tienes que poner en juego esto con los algoritmos de ordenación, supongo que no te están pidiendo que crees los algoritmos así que te bastará con ver cómo funcionan y adaptarlos para hacer funcionar el programa, pero no será tarea sencilla.

[madness]

Ok bro, pero la verdad es que tengo muy poco conocimiento de estructura, ya que es primera vez que tomo esta asignatura . Según lo que explicó mi profesor es que debo también realizar el código, y ahí es donde me complica más, ya que no sé como usar la funcion Malloc para reservar una cierta cantidad de memoria para crear los arreglos según la cantidad que estime necesaria el usuario. Por ejemplo para generar un arreglo yo hacia lo siguiente:

#include <stdio.h>
#inclide <stdlib.h>

int main()
{
 int n, i, menor, mayor;
 printf("Ingrese el largo del arreglo a construir: ");
 scanf("%d", &n);
 int arreglo[n];
 //Desde aquí generaba un for, en donde se llenaba el arreglo hasta "n".
 //Luego haría otro for para ir chequeando y ordenando de menor a mayor
}

¿Cómo sería este mismo código pero estructurado y utilizando memoria dinámica?. De verdad me sería de gran ayuda si me dieras un empujonsito, ya que yo solito tuve que aprender C y en otra asignatura debo aprender Java desde 0 y, aunque me guste programar, con todo esto ya me quiero morir! jeje .

[Ogramar]

Aquí tienes un ejemplo de uso de un array dinámico basado en punteros, puedes usar esta misma lógica:

Código: [Seleccionar]

#include <stdio.h>
#include <stdlib.h>

 struct _numeroDinamico {
        int numero;

        struct _numeroDinamico *siguiente;
        };

 struct _numeroDinamico *primero, *ultimo;

 void mostrar_menu() {
      printf("\n\nMenu:\n=====\n\n");
      printf("1.- Añadir elementos\n");
      printf("2.- Borrar elementos\n");
      printf("3.- Mostrar lista\n");
      printf("4.- Salir\n\n");
      printf("Escoge una opcion: ");
 }

 /* Con esta función añadimos un elemento al final de la lista */
 void anadir_elemento() {
      struct _numeroDinamico *nuevo;

      /* reservamos memoria para el nuevo elemento */
      nuevo = (struct _numeroDinamico *) malloc (sizeof(struct _numeroDinamico));
      if (nuevo==NULL) printf( "No hay memoria disponible!\n");

      printf("\nNuevo elemento:\n");
      printf("Numero: "); fflush(stdout);

      scanf("%d", &nuevo->numero);
      /* el campo siguiente va a ser NULL por ser el último elemento
         de la lista */
      nuevo->siguiente = NULL;

      /* ahora metemos el nuevo elemento en la lista. lo situamos
         al final de la lista */
      /* comprobamos si la lista está vacía. si primero==NULL es que no
         hay ningún elemento en la lista. también vale ultimo==NULL */
      if (primero==NULL) {
         printf( "Primer elemento\n");
         primero = nuevo;
         ultimo = nuevo;
         }
      else {
           /* el que hasta ahora era el último tiene que apuntar al nuevo */
           ultimo->siguiente = nuevo;
           /* hacemos que el nuevo sea ahora el último */
           ultimo = nuevo;
      }
 }

 void mostrar_lista() {
      struct _numeroDinamico *auxiliar; /* lo usamos para recorrer la lista */
      int i;

      i=0;
      auxiliar = primero;
      printf("\nMostrando la lista completa:\n");
      while (auxiliar!=NULL) {
            printf( "Numero: %d\n",
                    auxiliar->numero);
            auxiliar = auxiliar->siguiente;
            i++;
      }
      if (i==0) printf( "\nLa lista está vacia!!\n" );
 }

 int main() {
     int opcion;

     primero = (struct _numeroDinamico *) NULL;
     ultimo = (struct _numeroDinamico *) NULL;
     do {
         mostrar_menu();
         scanf ("%d", &opcion);
             switch ( opcion ) {
                case 1: anadir_elemento();
                       break;
                case 2:  printf("No disponible todavia!\n");
                        break;
                case 3: mostrar_lista(primero);
                        break;
                case 4: exit( 1 );
                default: printf( "Opcion no válida\n" );
                         break;
             }
     } while (opcion!='4');
     return 0;
 }

[madness]

Ogramar ! te agradesco demaciado por tu dedicación y tiempo para solucionar mi problema ! De verdad ! . Mientras esperaba tu respuesta me guie por videos en youtube e información de google, y este es parte del código que he construído:

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

int main()
{
 int *arreglo, i=0, j;
 arreglo=(int*)malloc(n*sizeof(double));    //La variable n es la cantidad de numeros que se guardaran en el array.
 if(arreglo==NULL){ printf("<ERROR: No se ha generado espacio suficiente en la memoria>\n"); }
 else
 { 
  aleatorio(arreglo, n);
  j++;
  for(i=0;i<n;i++)
  {
   if(*(arreglo+i)>*(arreglo+j)) //Si el arreglo en posicion i es mayor a arreglo en posicion j
   {
    // Ahora no se como ir cambiando de posicion en caso de que cumpla la condición siendo punteros!    
   }
  }
 }
}

No entiendo parte de tu codigo al haber variables con "->" y, ¿Qúe hacer en caso de que no haya espacio suficiente en mi memoria?. Sé que he molestado mucho jaja pero con solo saber que hacer en el if, creo que ya tendría gran parte de mi tarea hecha y te lo agradecería tanto x.x jaja . Saludos bro!

[Ogramar]

Para pegar código usa el botón # del editor del foro y pon el código entre las etiquetas [ code] ... [ / code], así saldrá como código.

Sobre el uso de ->:

auxiliar->numero significa lo siguiente: "campo numero de la variable tipo struct auxiliar".

Es decir, cuando declaras un struct tienes varios campos, imagina que declaras un struct que se llama persona y que los campos son nombre, apellidos, telefono, direccion, etc.

Luego podrías rellenar cada campo así:

persona->nombre = "Juan"
persona->apellidos ="Perez"
persona->telefono="06345234"
persona->direccion="encinar 20 Mexico D.F."

[madness]

Ogramar! sé que es un poco tarde mi respuesta jaja, pero ya logre hacer la tarea, y me fue mejor de lo que esperaba a pesar de no saber mucho jaja. Agradesco tu ayuda y espero que te hagas presente en próximas dudas que tenga xD Gracias!

[Ogramar]

Bueno, siempre se agradece saber si se ha solucionado o no y cómo salu2