Как отсортировать строки по кол-ву слов и слова в строке по длине слов

#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <ctype.h>
#define MAX_BUF   256
 
typedef struct {
    char** arr;
    size_t cnt;
    size_t num;
} arrptr_t;
 
typedef struct node {
    struct node* next;
    char*  str;
    size_t cnt;
} slist;
 
void arrptr_init(arrptr_t* a);
void arrptr_reset(arrptr_t* a);
void arrptr_clear(arrptr_t* a);
int  arrptr_add(arrptr_t* a, char* w);
void arrptr_sort(arrptr_t* a);
char* next_prop(char** s, size_t* n);
void slist_fill(slist** lst, char* s);
void slist_sort(slist** lst);
void slist_clear(slist* lst);
 
int main(void){
    char   buf[MAX_BUF], fmt[16];
    slist* p, *lst = NULL;
 
    sprintf(fmt, "%%%d[^#]", MAX_BUF - 1);
    printf("Enter: ");
    scanf(fmt, buf);
 
    slist_fill(&lst, buf);
    //вывод предложений
    for(p = lst; p != NULL; p = p->next)
        printf("%s. ", p->str);
    slist_clear(lst);
    getchar();
    return 0;
}
 
//заполнение списка предложениями
void slist_fill(slist** lst, char* s){
    slist*   lp;
    size_t   i, n;
    arrptr_t arr;
    char*    w, *p;
    const char delim[] = " \t\n";
 
    arrptr_init(&arr);
    for(p = s; (w = next_prop(&p, &n)) != NULL; ){
        arrptr_reset(&arr);     
        for(w = strtok(w, delim); w != NULL; w = strtok(NULL, delim))
            arrptr_add(&arr, w);
        arrptr_sort(&arr);
 
        if((lp = (slist*)malloc(sizeof(slist))) == NULL)
            break;
 
        lp->str = (char*)malloc((n + 1) * sizeof(char));
        if(lp->str == NULL){
            free(lp);
            break;
        }
 
        w  = lp->str;
        *w = '\0';
        for(i = 0; i < arr.cnt; ++i){
            strcpy(w, arr.arr[i]);
            w += strlen(arr.arr[i]);
            if((i + 1) < arr.cnt)
                *w++ = ' ';
        }
 
        lp->cnt  = arr.cnt;
        lp->next = *lst;
        *lst = lp;
    }
    arrptr_clear(&arr);
    slist_sort(lst);
}
 
//сортировка списка по убыванию кол-во слов
void slist_sort(slist** lst){
    slist* i, *a, *b, *p, *h = NULL;
 
    for(i = *lst; i != NULL; ) {
        a = i;
        i = i->next;
        b = h;
        for(p = NULL; (b != NULL) && (a->cnt < b->cnt); ) {
            p = b;
            b = b->next;
        }
 
        if(p == NULL){
            a->next = h;
            h       = a;
        } else {
            a->next = b;
            p->next = a;
        }
    }
    if(h != NULL) 
        *lst = h;   
}
 
//удаление списка
void slist_clear(slist* lst){
    slist* t;
    while(lst != NULL){
        t   = lst;
        lst = lst->next;
        free(t->str);
        free(t);
    }
}
 
void arrptr_init(arrptr_t* a){
    a->arr = NULL;
    a->cnt = a->num = 0;
}
 
void arrptr_reset(arrptr_t* a){
    a->cnt = 0;
}
 
//очистка
void arrptr_clear(arrptr_t* a){
    if(a->arr != NULL)
        free(a->arr);
    a->arr = NULL;
    a->cnt = a->num = 0;
}
 
//добавление
int arrptr_add(arrptr_t* a, char* w){
    char** t;
    size_t n;
    if(a->arr == NULL){
        n = 16;
        a->arr = (char**)malloc(n * sizeof(char*));
        if(a->arr == NULL)
            return 0;
        a->num = n;
    } else if(a->cnt >= a->num){
        n = a->cnt + (a->num >> 1);
        t = (char**)realloc(a->arr, n * sizeof(char*));
        if(t == NULL)
            return 0;
        a->arr = t;
        a->num = n;
    }
    a->arr[a->cnt++] = w;
    return 1;
}
 
//сортировка слов по длинне
void arrptr_sort(arrptr_t* a){
    char*  t;
    size_t x, y, i, j, k;
    for(i = 0; i < a->cnt; ++i){
        k = i;
        x = strlen(a->arr[i]);
        for(j = i + 1; j < a->cnt; ++j){
            y = strlen(a->arr[j]);
            if(x > y){
                x = y;
                k = j;
            }
        }
 
        if(i != k){
            t = a->arr[i];
            a->arr[i] = a->arr[k];
            a->arr[k] = t;
        }
    }
}
 
//поиск предложения
char* next_prop(char** s, size_t* n){
    char* t, *p = *s;
    while(*p){
        t = p;
        while(*p && (*p != '.'))
            ++p;
 
        if(t != p){
            if(*p)
                *p++ = '\0';
 
            while(isspace(*t))
                ++t;
 
            *s = p;
            *n = (size_t)(p - t);
            return t;
        } else if(*p)
            ++p;
    }
    return NULL;
}