Salve,
vi presento l'ennesimo problema con le liste lineari(non spaventatevi se il codice è lungo, la parte che m'interessa è solo una funzione):
codice:
/*  Accetta in ingresso una sequenza di valori interi terminante con zero e
 la memorizzi in una lista lineare con  funzione di conteggio(ex 5) degli elementi
 e stampa dell'n-esimo elemento della lista(ex 6). Funzione di
 ordinamento in ordine crescente(ex 7).  */

#include <stdio.h>
#include <malloc.h>
#include <string.h>

/* Struttura che determina gli elementi di una lista */ 
struct elemento {
    int inf;
    struct elemento *pun;
} *crea_lista(void);

typedef struct elemento ele;
/* Prototipi delle funzioni */

ele *cancella(ele*, int);
void *ordina_crescente(ele*);
void visualizza(ele*,char*);
int count(ele*);
void valore(ele*,int);


int main() {
    int n;
    ele *lista;   
    fflush(stdin);    
    lista = crea_lista();
    n = count(lista);  
    visualizza(lista,"lista");
    printf("\nNumero totale elementi: %d", n);
    printf("\nInserisci il numero dell'elemento: ");
    scanf("%d",&n);
    valore(lista,n);
    printf("\nInserisci il valore dell'elemento da cancellare: ");
    scanf("%d",&n);    
    lista = cancella(lista,n);
    visualizza(lista,"lista dopo cancellazione");
    ordina_crescente(lista);
    visualizza(lista,"lista ordinata");
    getchar();
    return 0; 
}

/* Funzione per l'accettazione dei valori immessi e la creazione della lista.
Restituisce un puntatore alla testa della lista */

ele *crea_lista(void) {
    ele *p, *paus;
    char scelta;
    int t;
     
    /* Creazione del primo elemento */
    p = (ele*)malloc(sizeof(ele));
    printf("\nInserisci il primo elemento: ");
    scanf("%d",&p->inf);
    fflush(stdin);
    paus = p;
    t = 1;
    
    /* Creazione degli elementi successivi */
    for(;;) {
        printf("\nVuoi inserire un\'altro elemento? [S/N]: ");
        scanf("%c",&scelta);
        fflush(stdin);
        if ((scelta=='s') || (scelta=='S') || (scelta=='n') || (scelta=='N')) {
            if((scelta=='s') || (scelta == 'S')) {
                paus->pun = (ele*)malloc(sizeof(ele));
                paus = paus->pun;
                t++;
                printf("\nInserisci il valore dell\'elemento %d: ",t);
                scanf("%d",&paus->inf);  
                fflush(stdin);
            } else  {
                paus->pun = NULL;
                break; 
              }
        } else printf("\nInserire un valore corretto!");
    } 
    return(p);                    
}

/* Routine per la stampa di un'elemento */
void valore(ele *p,int n) {
    int i = 1;
    ele* paus;
    if ((n > count(p)) || (n < 0)) printf("\nLa lista non contiene un numero sufficente di elementi");
    else {
        paus = p;
        for(i = 1; paus!=NULL; i++) {
            if (i == n) break;
            else paus = paus->pun;
        }
        printf("Valore dell'elemento %d: %d",n,paus->inf);
    }
}                                 

/* Funzione per il conteggio degli elemenenti della lista */
int count(ele *p) {
    int i = 0; 
    ele *paus;  
    paus = p; 
    while (paus!=NULL) {
        i++;
        paus = paus->pun;
    }
    return(i);
}

/* Routine per la visualizzazione della lista */
void visualizza(ele *p,char *tipo) {
    int i = 1;
    printf("\n\n\t\tVisualizzazione %s\n",tipo);
    while(p!=NULL) {                                   
        printf("\nElemento %d: %d",i,p->inf);
        p = p->pun; 
        i++; 
    }
    printf("\n\n\t\t--------------------\n\n");
    getchar();
}

/* Routine per l'eliminazione delle occorrenze di n nella lista */
ele *cancella(ele *p,int n) {
    ele *paus;
    int logica = 1;
    printf("\n\n\t\tEliminazione occorrenze del %d....\n",n);
    while(p!=NULL && logica)      
      if(p->inf == n)
            if (p->pun==NULL) free(p);  
            else p = p->pun;
      else
            logica = 0;
    paus = p;
    while(paus->pun != NULL)
      if(paus->pun->inf == n)
        paus->pun = paus->pun->pun;
      else
        paus = paus->pun;
    return(p);
}

void *ordina_crescente(ele *p) {
    int i, j, aus;
    int *paus;
    ele *paus2;
    paus = (int*)malloc(sizeof(int)*count(p));
    paus2 = p;
    i = 0;
    visualizza(paus2,"paus2 prima");
    while((paus2->pun!= NULL) && (i<=count(p))) {
        *(paus+i) = paus2->inf;
        paus2 = paus2->pun;
        i++;
        printf("\nVettore riempito. paus2->inf = %d\tpaus2->pun != NULL: %d\tvettore[%d] = %d\ti<=count(paus2): %d",paus2->inf,paus2->pun != NULL,i,*(paus+i),i<=count(paus2));
        getchar();
    }
    paus2 = p;
    visualizza(paus2,"paus2 dopo");
    for(i = 0; i<=count(p); i++) printf("\n%d Elemento %d del vettore: %d",count(paus2),i,*(paus+i));
    for(i = 1; i<=count(p); i++) {
        for(j = 1; i<=count(p); j++) {
            if(*(paus+j)<*(paus+i)) {
                aus = *(paus+j);
                *(paus+j) = *(paus+i);
                *(paus+i) = aus;
            }
        }
    }
    i = 0;
    paus2 = p;
    while((paus2->pun!= NULL) && i<=count(p)) {
        paus2->inf = *(paus+i);
        paus2 = paus2->pun;
        i++;
    }  
    visualizza(paus2,"lista in ordine crescente");
}
Esattamente la parte:
codice:
void *ordina_crescente(ele *p) {
    int i, j, aus;
    int *paus;
    ele *paus2;
    paus = (int*)malloc(sizeof(int)*count(p));
    paus2 = p;
    i = 0;
    visualizza(paus2,"paus2 prima");
    while((paus2->pun!= NULL) && (i<=count(p))) {
        *(paus+i) = paus2->inf;
        paus2 = paus2->pun;
        i++;
        printf("\nVettore riempito. paus2->inf = %d\tpaus2->pun != NULL: %d\tvettore[%d] = %d\ti<=count(paus2): %d",paus2->inf,paus2->pun != NULL,i,*(paus+i),i<=count(paus2));
        getchar();
    }
    paus2 = p;
    visualizza(paus2,"paus2 dopo");
    for(i = 0; i<=count(p); i++) printf("\n%d Elemento %d del vettore: %d",count(paus2),i,*(paus+i));
L'assegnazione non avviene esattamente come prevedevo, gli ultimi valori sballano con valori altissimi, per capire compilatelo e provatelo: perchè succede questo? Dov'è il problema?

Grazie in anticipo.
PS: non guardate il codice da quella parte in giù, ancora non l'ho ne provato ne controllato poikè sono rimasto bloccato lì.