Есть ли способ просматривать и сортировать элементы структуры в C с циклом for в порядке убывания?

Question

Я бы хотел отсортировать структуру из 24 различных элементов в порядке убывания. Но я не знаю, есть ли способ сделать это без использования указателей и таблиц в структуре. Я хочу сделать это просто с сохранением различных элементов, и после этого я просматриваю все свои элементы с помощью цикла for и сортирую их в порядке убывания !!

вот моя программа, мои имена переменных находятся на французском языке:

в моем заголовочном файле я объявляю это:

#define SEUIL 5

typedef struct BEO_acc BEO_acc;

// first structure to receive my element and affecte them to my 
variables 
struct BEO_acc{
int  Energie;
int  Kilometrage;
int date;
};

typedef struct Historique_BEO_acc Historique_BEO_acc;

// second structure where I want to store all my max values of 
energy given by the user 
struct Historique_BEO_acc{
int energie1;
int kilomtrage1;
int date1;
int energie2;
int kilomtrage2;
int date2;
int energie3;
int kilomtrage3;
int date3;
int energie4;
int kilomtrage4;
int date4;
int energie5;
int kilomtrage5;
int date5;
int energie6;
int kilomtrage6;
int date6;
int energie7;
int kilomtrage7;
int date7;
int energie8;
int kilomtrage8;
int date8;
 };

int FUN_beo_acc(int arg1, int arg2, int arg3);

А вот моя программа cpp:

#include "prototype_beo.h";
#include <stdio.h>;
#define SEUIL 5
#define RESET_VALUE 0


int FUN_beo_acc(int arg1, int arg2, int arg3)
{
BEO_acc accumulateur;
accumulateur.Energie = arg1;
accumulateur.Kilometrage = arg2;
accumulateur.date = arg3;


return accumulateur.Energie;
}



int main(int argc, char *argv[])
{
BEO_acc accumulateur = {RESET_VALUE, RESET_VALUE, RESET_VALUE};
Historique_BEO_acc Historique = {RESET_VALUE, RESET_VALUE, 
RESET_VALUE, RESET_VALUE, RESET_VALUE, RESET_VALUE, 
RESET_VALUE, RESET_VALUE, RESET_VALUE};
int seuil = SEUIL;
int returned_arg;
int v1, v2, v3;



printf("introduire le premier argument de la fonction \n");
scanf("%d", &v1);
printf("introduire la valeur du deuxième argument ");
scanf("%d", &v2);
printf("introduire la valeur du troisième argument ");
scanf("%d", &v3);
returned_arg = FUN_beo_acc(v1, v2, v3);

while(returned_arg < seuil)
{
printf("introduire le premier argument de la fonction \n");
scanf("%d", &v1);
printf("introduire la valeur du deuxième argument ");
scanf("%d", &v2);
printf("introduire la valeur du troisième argument ");
scanf("%d", &v3);
returned_arg = FUN_beo_acc(v1, v2, v3); 
}

if (returned_arg > seuil)
{
    accumulateur.Energie = returned_arg;
    accumulateur.Kilometrage = v2+10;
    accumulateur.date = v3+10;

    printf("l''energie max est de : %d ", 
    accumulateur.Energie);
    printf("la distance est de : %d ", 
    accumulateur.Kilometrage);
    printf("la date  est de : %d ", accumulateur.date);
    }
    }

на данный момент я только что сделал некоторые входные значения, и яхранить их в первой структуре. Я хочу каждый раз, когда моя энергия больше 5, я буду хранить ее в великой структуре. в конце своего хранения я отсортирую свою великую структуру и расположу значения в порядке убывания энергии.

Answer 1

Когда вы создаете объекты с именами, такими как thing1, thing2, thing3, это сильный намек, что вы хотите использовать массив .

Iпредложил бы переопределить struct Historique_BEO_acc как массив из struct BEO_acc:

struct BEO_acc Historique_BEO_acc[N]; // where N is the number of elements you want to store

Вы бы записали в каждый элемент как

Historique_BEO_acc[i].Energie = ...;
Historique_BEO_acc[i].Kilomitrage = ...;
Historique_BEO_acc[i].date = ...;

Затем вы можете использоватьqsort() библиотечная функция для сортировки массива. Вам просто нужно написать функцию сравнения, чтобы сообщить qsort(), как упорядочить элементы. Если вы хотите отсортировать по Energie в порядке убывания, ваша функция будет выглядеть примерно так:

int cmp_beo( const void *l, const void *r )
{
  const struct BEO_acc *ll = l;
  const struct BEO_acc *lr = r;

  if ( ll->Energie < lr->Energie )
    return 1;
  else if ( ll->Energie > lr->Energie )
    return -1;
  else 
    return 0;
}

, тогда вы будете вызывать qsort() как

qsort( Historique_BEO_acc, N, sizeof Historique_BEO_acc, cmp_beo);

Answer 2

После некоторого размышления я думаю, что мы можем сделать это описанным ниже способом, без использования указателей или функции qsort:

BEO_acc accumulateur = {RESET_VALUE, RESET_VALUE, RESET_VALUE};
BEO_acc hist_BEO[TAILLE_MEMOIRE_REQUISE] = {accumulateur,accumulateur,accumulateur, 
{9,6,5},accumulateur,accumulateur,accumulateur,accumulateur};
int x = 0, xx = 0, xxx = 0;
    for(int j=0;j<TAILLE_MEMOIRE_REQUISE;j++)
{
    for (int i=0; i< TAILLE_MEMOIRE_REQUISE; i++)
    {
        if(hist_BEO[i].Energie>hist_BEO[i+1].Energie)
            {
                x = hist_BEO[i+1].Energie;
                xx = hist_BEO[i+1].Kilometrage;
                xxx = hist_BEO[i+1].date;

                hist_BEO[i+1].Energie = hist_BEO[i].Energie;
                hist_BEO[i+1].Kilometrage = hist_BEO[i].Kilometrage;
                hist_BEO[i+1].date = hist_BEO[i].date;

                hist_BEO[i].Energie = x;
                hist_BEO[i].Kilometrage = xx;
                hist_BEO[i].date = xxx;

                x = 0;
                xx = 0;
                xxx = 0;
            }
           }
           }

И спасибо за предложения.

Answer 3

Прежде всего не используйте «большую структуру» для хранения данных только таблицы «малых структур». Тогда вы можете легко отсортировать его, как вам нужно. Пример:

typedef struct {
int  Energie;
int  Kilometrage;
int date;
}BEO_acc;



int compare(const void *elem1, const void *elem2)  //energy is always positive :)
{
    return ((BEO_acc *)elem1) -> Energie - ((BEO_acc *)elem2)  -> Energie;
}


BEO_acc *histData = NULL;



int main()
{
    int count  = 30;
    size_t nrecords = 0;
    BEO_acc acc;
    while(count--)
    {
        acc.Energie = rand() % 500;
        if(acc.Energie > 300)
        {
            BEO_acc *tmp = realloc(histData, (nrecords + 1) * sizeof(acc));
            if(tmp)
            {
                histData = tmp;
                histData[nrecords++] = acc;
            }
            else
            {
                //error actions
            }
        }
    }
    printf("\nBefore qsort:\n");
    for(size_t index = 0; index < nrecords; index++)
    {
        printf("%05zu - %d\n", index, histData[index].Energie);
    }
    qsort(histData, nrecords, sizeof(*histData), compare);
    printf("\nAftrer qsort:\n");
    for(size_t index = 0; index < nrecords; index++)
    {
        printf("%05zu - %d\n", index, histData[index].Energie);
    }
}

Вы можете играть с ним самостоятельно: https://onlinegdb.com/rJ-fdGqHoB