Сортировка пузырьком массива структур по одному из полей - C (СИ)

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

Помогите сделать символьную сортировку пузырьком для "avtor" , заранее спасибо)

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct book 
{ 
    char name[16]; 
    char izd[32]; 
    char year[64];
    char pg[64];
    char avtor;
};
struct List 
{
    book sotr; 
    List *pNext; 
};

void addFirst(List *& pF, List* p) 
{
    p->pNext = pF;
    pF = p;
}
 
List * delFirst(List *&pF) 
{
    if (pF == 0) return 0;
    List *p = pF;
    pF = pF->pNext;
    return p;
}
 
bool add(List *&pF, List * pZad, List *p)
{
    
    if (pZad == pF) 
    {
        p->pNext = pF;
        pF = p;
        return true;
    }
    List *pPred = pF; 
    while (pPred->pNext != pZad && pPred->pNext)
        pPred = pPred->pNext;
    if (pPred->pNext == 0) return false; 
    p->pNext = pZad;
    pPred->pNext = p;

    return true;
}
 
List * del(List*& pF, List *p) 
{
    if (pF == 0) return 0;
    if (pF == p) 
    {
        pF = pF->pNext;
        return p;
    }
    else
    {
        List *pPred = pF; 
        while (pPred->pNext != p && pPred->pNext)
            pPred = pPred->pNext;
        if (pPred->pNext == 0) return 0; 
        pPred->pNext = p->pNext;
        return p;
    }
    while (delFirst(pF)); 
}
int main(int argc, char* argv[])
{
    List *pF = 0; 
    List *p;
    
    char Ch; 
    do
    {
        p = (List *)malloc(sizeof(List)); 
        
        printf("maxspid: ");
        fflush(stdin); gets_s(p->sotr.name);
        printf("power: ");
        fflush(stdin); gets_s(p->sotr.izd);
        printf("trass:");
        fflush(stdin); gets_s(p->sotr.year);
        printf("city:");
        fflush(stdin); gets_s(p->sotr.pg);
        printf("avtor:");
        fflush(stdin); scanf_s("%s",p->sotr.avtor);
        addFirst(pF, p);
        printf("For continue press Y or y else any key! ");
        Ch = _getche(); 
    } while (Ch == 'Y' || Ch == 'y');

    for (List *pi = pF; pi->pNext;)
    {
        
        double min = pi->sotr.avtor;
        List *pmin = pi;
        for (List *pj = pi->pNext; pj; pj = pj->pNext)
            if (pj->sotr.avtor<min)
            {
                min = pj->sotr.avtor;
                pmin = pj;
            }
        if (pi != pmin) 
        {
            del(pF, pmin);
 
            add(pF, pi, pmin);
        }
        else pi = pi->pNext;
    }
    
    printf("\nSrting:");
    for (List *pi = pF; pi; pi = pi->pNext) 
        printf("\n avtor- %s ",  pi->sotr.avtor);
    printf("\nFor exit press any key ");
    system("pause"); 
    return 0;
}

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

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

#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <stdlib.h>
 
struct book { 
    char name[16]; 
    char izd[32]; 
    char year[64];
    char pg[64];
    char avtor;
};
 
struct List {
    struct book sotr; 
    struct List *pNext; 
};
 
void List_Add(struct List** lst, struct book* b){
        struct List* p = (struct List*)malloc(sizeof(struct List));
        if(p != NULL){
                memcpy(&p->sotr, b, sizeof(*b));
                p->pNext = *lst;
                *lst = p;
        }
}
 
//сортировка списка методом Пузырька
void List_BSort(struct List** lst, int (*cmp)(const struct book*, const struct book*)){
    int    chk;
    struct List* p, *a, *b, *t1, *t2;
    if((*lst == NULL) || ((*lst)->pNext == NULL))
        return;
    do {
        chk   = 0;
        a = p = (*lst);
        b = (*lst)->pNext;
        while(b != NULL){
            if((*cmp)(&b->sotr, &a->sotr)){
                t2 = p;
                t1 = b->pNext;
 
                if(a == *lst)
                    *lst = b;
                else
                    p->pNext = b;
 
                b->pNext = a;
                a->pNext = t1;
 
                t1  = a;
                a   = b;
                b   = t1;
                p   = t2;
                chk = 1;
            }
            p = a;
            a = a->pNext;
            b = b->pNext;
        }
    } while(chk);
}
 
static int compare(const struct book* a, const struct book* b){
        return (a->avtor < b->avtor);
}
 
 
int main(void){
        int i;
        struct book  b;
        struct List* p, *lst = NULL;
 
        for(i = 0; i < 10; ++i){
                b.avtor = 'A' + (rand() % 12);
                sprintf(b.name, "USER-%d", i);
                List_Add(&lst, &b);
        }
 
        for(p = lst; p != NULL; p = p->pNext){
                printf("%c - %s\n", p->sotr.avtor, p->sotr.name);
        }
        putchar('\n');
        
        //сортируем
        List_BSort(&lst, compare);
        
        for(p = lst; p != NULL; p = p->pNext){
                printf("%c - %s\n", p->sotr.avtor, p->sotr.name);
        }        
        return 0;
}

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

Структура book содержит поля name, izd, year, pg и avtor.
Структура List содержит поле sotr типа book и указатель pNext на следующий элемент списка.
Функция List_Add добавляет новый элемент списка, содержащий копию переданного ей элемента b.
Функция List_BSort использует метод Пузырька для сортировки списка по полю avtor структур book.
Статическая функция compare сравнивает два элемента списка по полю avtor.
В функции main создается список из 10 элементов, добавляемых с помощью функции List_Add.
Список выводится на экран с помощью цикла for.
Затем список сортируется с помощью функции List_BSort и выводится на экран снова.
Для сортировки используется метод Пузырька, который сравнивает пары соседних элементов и меняет их местами, если они стоят не в нужном порядке.
Цикл do-while в функции List_BSort продолжается, пока не будет отсортирован в нужном порядке.
Значение chk используется для контроля корректности работы алгоритма сортировки.
Значение p используется как временная переменная в процессе сортировки.
Значение a используется как текущий элемент списка.
Значение b используется как следующий элемент списка.
Значение t1 используется как временная переменная для хранения p->pNext.
Значение t2 используется как временная переменная для хранения p.
Значение t1 используется как временная переменная для хранения a->pNext.
Значение t2 используется как временная переменная для хранения a.
Значение a используется как следующий элемент списка после b.
Значение b используется как текущий элемент списка.