Необходимо отсортировать однонаправленный список. - C (СИ)

Формулировка задачи:

Необходимо создать однонаправленный список и реализовать в нём все действия...Получилось сделать всё кроме сортировки...необходимо переставлять не значения а указатели...помогите кто может метод сортировки любой... Вот что у меня получилось

#include <stdio.h>
#include <stdlib.h>
 
int Add(int);
void Print(void); 
void Destroy(void);  
int Delete(int);
void Sort(void);
 
typedef struct _ELEMENT{
    int value;
    struct _ELEMENT *next;
} ELEMENT;
ELEMENT *head=NULL;
 
int main(int argc, char *argv[])
{
    int n,e,m;
    printf("Vedite kolichestvo elementov spiska : ");
    scanf("%d",&n);
    for(int i=0;i<n;i++){
    printf("element [%d] = ",i+1);
    scanf("%d",&e);
    Add(e);
    }
    //printf("//vvedite nomer ydalaemogo elementa : ");
    //scanf("%d",&m);
    //Delete(m);
    Sort();
    Print();
    Destroy();
    return 0;
}
 
void Sort(void){
    int a=1;
    ELEMENT *tmp, *pred;
    while(a==1){
        a=0;
        tmp=head;
        pred=NULL;
        while(tmp->next!=NULL){
            if(tmp->value>tmp->next->value){
                a=1;
 
           // Тут я уже потерялся в указателях
            }
        pred=tmp;
        tmp=tmp->next;
        }
    }
}

int Delete(int num){
    ELEMENT *tmp=head;
    if(num==1){
        head=head->next;
        free(tmp);
    }else{
        int ind=1;
        while(ind+1!=num){
            tmp=tmp->next;
            ind++;
        }
        ELEMENT *cur=tmp;
        cur=tmp->next;
        tmp->next=tmp->next->next;
        free(cur);
    }
    return 0;
}
 
int Add(int value){
    ELEMENT *tmp=(ELEMENT*)malloc(sizeof(ELEMENT));
    if(!tmp){
        printf("kosak");
        return 0;
    }
    if(!head){
        tmp->next=NULL;
        head=tmp;
    }else{
        ELEMENT *cur=head;
        while(cur->next)
            cur=cur->next;
        tmp->next=cur->next;
        cur->next=tmp;
    }
    tmp->value=value;
    return 0;
}
 
void Destroy(void){
    while(head){
    ELEMENT *tmp=head;
        head=head->next;
        free(tmp);
    }
}
 
void Print(void){
    ELEMENT *tmp=head;
    int num=1;
    while(tmp){
        head=head->next;
        printf("Element [%d] = %d \n",num, tmp->value);
        num++;
        tmp=tmp->next;
    }   
}

Решение задачи: «Необходимо отсортировать однонаправленный список.»

Листинг программы

#include <stdio.h>
#include <stdlib.h>
 
typedef struct NODE {
    int * val;
    struct NODE * next;
} node_t;
 
node_t * new_node(int val){
    node_t * n;
 
    if ( ( n = (node_t*)malloc(sizeof(node_t)) ) == NULL )
        return NULL;
    if ( ( n->val = (int*)malloc(sizeof(int)) ) == NULL ){
        free(n);
        return NULL;
    }
    *(n->val) = val;
    n->next = NULL;
 
    return n;
}
 
node_t * del_node(node_t * n){
    node_t * ret;
 
    if ( ! n )
        return NULL;
    ret = n->next;
    free(n->val);
    free(n);
 
    return ret;
}
 
node_t * min_node_val(const node_t * first){
    const node_t * ret = first;
    
    while ( first = first->next )
        if ( *(first->val) < *(ret->val) )
            ret = first;
 
    return (node_t*)ret;
}
 
node_t * max_node_val(const node_t * first){
    const node_t * ret = first;
 
    while ( first = first->next )
        if ( *(first->val) > *(ret->val) )
            ret = first;
 
    return (node_t*)ret;
}
 
void swap_node_values(node_t * a, node_t * b){
    int tmp = *(a->val);
    *(a->val) = *(b->val);
    *(b->val) = tmp;
}
 
typedef struct LIST {
    node_t * first;
    node_t * last;
} list_t;
 
list_t * new_list(void){
    list_t * ret;
 
    if ( ( ret = (list_t*)malloc(sizeof(list_t)) ) == NULL )
        return NULL;
 
    ret->first = ret->last = NULL;
 
    return ret;
}
 
void del_list(list_t * list){
    while ( list->first = del_node(list->first) )
        ;
    free(list);
}
 
int add_node(list_t * list, int val){
    node_t * n;
    if ( ( n = new_node(val) ) == NULL )
        return -1;
    
    if ( ! list->first )
        list->first = n;
    else 
        list->last->next = n;
    list->last = n;
 
    return 0;
}
 
void sort_ascendant(list_t * list){
    node_t * first;
    node_t * min;
 
    for ( first = list->first; first->next; first = first->next )
        if ( ( min = min_node_val(first) ) != first )
            swap_node_values(first, min);
}
 
void sort_descendant(list_t * list){
    node_t * first;
    node_t * max;
 
    for ( first = list->first; first->next; first = first->next )
        if ( ( max = max_node_val(first) ) != first )
            swap_node_values(first, max);
}
 
void dump(const list_t * list){
    const node_t * n;
 
    for ( n = list->first; n; n = n->next )
        printf("%d ", *(n->val));
    printf("\n");
}
 
int main(void){
    list_t * list;
    int i;
 
    if ( ( list = new_list() ) == NULL ){
        fprintf(stderr, "Memory error!\n");
        exit(1);
    }
 
    printf("Enter some numbers (any letter - finish):\n");
    while ( printf("> ") && scanf("%d", &i) == 1 ){
        if ( add_node(list, i) ){
            fprintf(stderr, "Memory error!\n");
            exit(1);
        }
    }
 
    if ( ! list->first ){
        fprintf(stderr, "No data!\n");
        exit(1);
    }
 
    printf("Unsorted:   ");
    dump(list);
 
    printf("Ascendant:  ");
    sort_ascendant(list);
    dump(list);
 
    printf("Descendant: ");
    sort_descendant(list);
    dump(list);
 
    del_list(list);
    system("pause");
 
    exit(0);
}

Объяснение кода листинга программы

Структура данных, используемая в коде - однонаправленный список, представленный с помощью связного списка.
В начале кода определены функции для работы со связным списком:
- new_node() - создает новый узел списка.
- del_node() - удаляет узел списка.
- min_node_val() - возвращает минимальное значение среди узлов списка.
- max_node_val() - возвращает максимальное значение среди узлов списка.
- swap_node_values() - меняет значения в двух узлах списка.
- new_list() - создает новый список.
- del_list() - удаляет список.
- add_node() - добавляет новый узел в список.
- sort_ascendant() - сортирует список в порядке возрастания.
- sort_descendant() - сортирует список в порядке убывания.
- dump() - выводит содержимое списка.
В функции main() создается новый список и заполняется данными, введенными пользователем.
Затем список сортируется в порядке возрастания и выводится на экран.
После этого список сортируется в порядке убывания и также выводится на экран.
В конце программы список освобождается с помощью функции del_list().