#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
void crearArreglo(int **punteroApuntero, int dim);
void asignarMemoria(int **punteroApuntero, int dim );
void copiarValores(int *puntero, int dim);
 
int main()
{
    int *pArreglo = NULL;
    int dim = 0; //dimension
 
    printf("\nIngrese la dimension del arreglo: ");
    scanf("%d",&dim);
 
    srand(time(NULL)); //para obtener valores random en copiarValores()
    crearArreglo(&pArreglo,dim); //se le pasa el puntero a puntero y la dimension
 
    printf("\nPrimer elemento desde main: %d\n",*pArreglo);
 
    free(pArreglo); // recuerda que siempre que adquieres memorias a mano debes liberarla a mano.
 
    return 0;
 
}// fin main
 
void crearArreglo(int **punteroApuntero, int dim)
{
    asignarMemoria(punteroApuntero, dim);
 
    copiarValores(*punteroApuntero, dim);
 
}// fin funcion crearArreglo
 
void asignarMemoria(int **punteroApuntero, int dim)
{
    (*punteroApuntero) = (int *) malloc ( dim * sizeof(int) );
 
    if( (*punteroApuntero) == NULL )
    {
        printf("\nError en asignacion de memoria.\n");
        exit(EXIT_FAILURE);
    }//fin if
    else
    {
        printf("\nAsignacion de memoria exitosa.\n");
 
    } // fin else
 
} // fin funcion asignarMemoria
 
void copiarValores(int *puntero, int dim)
{
    for(int i=0; i<dim; ++i)
    {
        puntero[i] = rand() % 10;
        printf("Elemento %d : %d\n",i,puntero[i]);
        system("pause");
    }// te lo cambio por un for. Es más conciso en este caso
 
} // fin funcion copiarValores

typedef struct tDATO {
	int DNI;
	char * nombre;
	struct tDATO *siguiente;
} *DATO;

typedef struct tCola {
    DATO primero;
    DATO ultimo;
    size_t n_elementos;
} *COLA;

DATO dato_crear(int dni, char *nombre) {
    DATO dato = malloc(sizeof(struct tDATO));
    dato->DNI = dni;
    dato->nombre = malloc((strlen(nombre)+1) * sizeof(char));
    strcpy(dato->nombre, nombre);
    dato->siguiente = NULL;
 
    return dato;
}

DATO dato_crear(int dni, char *nombre) {
    ...
    dato->nombre = nombre;
    ...
}

void generar_dato() {
    ...
    char nombre[] = "Tirant Lo Blanc";
    dato_crear(dni, nombre);
    ...
}

void dato_liberar(DATO dato) {
    free(dato->nombre);
    free(dato);
}

COLA cola_crear() {
    COLA cola = malloc(sizeof(struct tCola));
    cola->primero = NULL;
    cola->ultimo = NULL;
    cola->n_elementos = 0;
 
    return cola;
}

void cola_agregar(COLA cola, DATO dato) {
    if(cola_es_vacia(cola)) {
        cola->primero = dato;
    } else {
        cola->ultimo->siguiente = dato;
    }
    cola->ultimo = dato;
    cola->n_elementos++;
}

DATO cola_extraer(COLA cola) {
    DATO dato = cola->primero;
 
    if(!cola_es_vacia(cola)) {
        cola->primero = cola->primero->siguiente;
        dato->siguiente = NULL;
        if(cola->primero == NULL) {
            cola->ultimo = NULL;
        }
        cola->n_elementos--;
    }
 
    return dato;
}

void cola_liberar(COLA cola) {
    DATO x;
    while(cola->primero) {
        x = cola->primero;
        cola->primero = cola->primero->siguiente;
        dato_liberar(x);
    }
    free(cola);
}

int cola_es_vacia(COLA cola) {
    return cola->n_elementos == 0;
}
 
size_t cola_longitud(COLA cola) {
    return cola->n_elementos;
}
 
 

#include <stdio.h>
#include <stdlib.h>
 
typedef struct rNodo {
    int dato;
    struct rNodo * siguiente;
} tNodo;
 
typedef struct rLista {
    tNodo * primero;
    tNodo * ultimo;
    int longitud;
} tLista;
 
typedef tNodo * Nodo;
typedef tLista * Lista;
 
tLista* inicializar();
tNodo* crear_nodo(int nuevo_dato);
void ins_de_orden_ascen(Lista lista, Nodo nuevo_nodo);
void mostrar(Lista lista);
void liberar(Lista lista);
 
int main(void) {
    Lista lista = inicializar();
    int nuevo_dato;
    int continuar; // cambio el nombre de variable para hacerlo  más coherente. No lo inicializo ya que en el bucle se debe hacer obligatoriamente.
	do {
		printf("ingrese un numero: ");
        scanf("%i", &nuevo_dato);
        ins_de_orden_ascen(lista, crear_nodo(nuevo_dato));
        printf("Quiere ingresar otro numero? 1(si) o 0(no): ");
        scanf("%i", &continuar);
    } while (continuar);
 
    mostrar(lista);
    liberar(lista);
    return 0;
}
 
 
tLista* inicializar() { // no tiene razón la existencia de un argumento, no se usaba
    Lista nueva_lista = malloc(sizeof (tLista));
    nueva_lista->primero = NULL;
    nueva_lista->ultimo = NULL;
    nueva_lista->longitud = 0;
    return nueva_lista;
}
 
tNodo* crear_nodo(int nuevo_dato) {
    Nodo nuevo_elemento = malloc(sizeof (tNodo));
    nuevo_elemento->dato = nuevo_dato;
    nuevo_elemento->siguiente = NULL;
    return nuevo_elemento;
}
 
void ins_de_orden_ascen(Lista lista, Nodo nuevo_nodo) { // no tiene razón que se devuelva la lista, no se modifica su puntero
    if (lista->longitud == 0) { // Si la lista es vacia
        nuevo_nodo->siguiente = lista->primero;
        lista->primero = nuevo_nodo;
        lista->ultimo = nuevo_nodo;
    } else {
        Nodo aux = lista->primero; // aux apunta al primer elemento
        Nodo ant = NULL;
        while(aux && aux->dato < nuevo_nodo->dato) { // busco el nodo con un dato mayor al nuevo dato, también puede llegar al fin de la lista
            ant = aux; // y me quedo con el nodo anterior
            aux = aux->siguiente;
        }
        if(ant) { // si el nodo anterior existe
            ant->siguiente = nuevo_nodo; // hago que su siguiente apunte al nuevo nodo
            if(lista->ultimo == ant) { // si el nodo anterior era el último de la lista
                lista->ultimo = nuevo_nodo; // ahora debe serlo el nuevo nodo
            }
        } else {
            lista->primero = nuevo_nodo; // en caso contrario quiere decir que el nuevo nodo debe ser el primero
        }
        nuevo_nodo->siguiente = aux; // el siguiente del nodo nuevo debe ser el nodo que debía ser el siguiente, o NULL si había llegado al final de la lista
 
    }
    lista->longitud++; // Aumenta la cantidad de elementos
}
 
void mostrar(Lista lista) { // pinta la lista en pantalla
    puts("--- Lista ---");
    if(!lista) { // No existe lista
        printf("Lista no inicializada");
        return;
    }
    if(lista->longitud == 0) { // Lista vacía
        printf("Lista vacía");
        return;
    }
 
    for(Nodo n = lista->primero; n; n = n->siguiente) { // Muestra todos los nodos
        printf("%d\n", n->dato);
    }
}
 
void liberar(Lista lista) { // Desaloja la lista de la memoria
    Nodo sig;
    if(!lista) { // Si no existe lista no hay que liberar nada
        return;
    }
    while(lista->primero) {
        sig = lista->primero->siguiente;
        free(lista->primero);
        lista->primero = sig;
        // lista->longitud--; // No hace falta esta línea ya que la lista se va a desalojar de la memoria
    }
    free(lista);
}