c++ ordena con estructuras

arrays sorting

Question

Estoy teniendo problemas con este problema, que requiere una especie de nombre de cliente, ID de cliente y, finalmente, el monto adeudado. Tengo todo el programa calculado, pero no puedo descifrar el último prototipo necesario para hacer la clasificación. tengo una estructura llamada Clientes, y también proporcionaré la parte int main (). Solo necesito ayuda para comenzar con el prototipo SortData ().

struct Customers {
    string Name;
    string Id;
    float OrderAmount;
    float Tax;
    float AmountDue;
};

const int MAX_CUSTOMERS = 1000;
bool MoreCustomers(int);
Customers GetCustomerData();
void OutputResults(Customers [], int);
void SortData(const int, const int, Customers []);

int main() {
    Customers c[MAX_CUSTOMERS]; 
    int Count = 0;      
    do {
      c[Count++] = GetCustomerData();   
    } while (MoreCustomers(Count));     


    for (int i = 0; i < Count; i++) {
        c[i].Tax = 0.05f * c[i].OrderAmount;        
        c[i].AmountDue = c[i].OrderAmount + c[i].Tax;   
    }

    SortData(0, Count, c);     //0:Sorts by customer name       
    OutputResults(c, Count);            
    GeneralSort(1, Count, c);   //1:Sorts by ID     
    OutputResults(c, Count);        
    GeneralSort(2, Count, c);   //2: Sorts by amount due        
    OutputResults(c, Count);        

    return 0;                       
}


void SortData(const int SortItem, const int count, CustomerProfile c[]) {
     //0: Sort by name
    //1: Sort by ID
    //3: Sort by amount due
}

Answer 1

A menudo se pasa por alto que puede usar funciones de rango STL con matrices basadas en C, como en su ejemplo. Entonces no tienes que moverte a usar un contenedor basado en STL (no debatiré los méritos de hacerlo aquí :-)).

Entonces, basándose en la respuesta de Chris, podría invocar el género de la siguiente manera:

std::sort( customers, customers+Count, &customer_sorter);

Answer 2

Debe usar la función de clasificación estándar de C ++, std::sort , declarada en el encabezado <algorithm> .

Cuando ordena utilizando una función de clasificación personalizada, debe proporcionar una función de predicado que indique si el valor de la mano izquierda es menor que el valor de la mano derecha. Por lo tanto, si primero desea ordenar por nombre, luego por ID, luego por cantidad adeudada, todo en orden ascendente, podría hacer lo siguiente:

bool customer_sorter(Customer const& lhs, Customer const& rhs) {
    if (lhs.Name != rhs.Name)
        return lhs.Name < rhs.Name;
    if (lhs.Id != rhs.Id)
        return lhs.Id < rhs.Id;
    return lhs.AmountDue < rhs.AmountDue;
}

Ahora pasa esa función a tu llamada de sort :

std::sort(customers.begin(), customers.end(), &customer_sorter);

Esto supone que tiene un contenedor STL (y no una matriz, como la que tiene en su código de muestra) llamados customers contienen clientes.

Answer 3

Puedes encontrar muchas implementaciones de ordenación en C ++ con creatividad en Google. La única diferencia es que en lugar de ordenar números, estás ordenando estructuras.

Entonces, donde haya algo como if(a[i]<a[j]) en el algoritmo que usará, haga una llamada como `if (isFirstCustomerLowerThanOther (a [i]

Ahora, crea una función con la siguiente estructura:

bool isFirstCustuomerLowerThanOther(const Customer& firstCustomer, const Customer& secondCustomer)
{
 // Implement based on your key preferences
}

Aún mejor, si usa C ++ puede usar el algoritmo de ordenación de STL (nuevamente, google para obtener información y cómo pasarle un pedido).

Answer 4

Solo necesita escribir una función de comparación que compare dos tipos de perfil de cliente. Una vez que tenga esta función, puede usar la clasificación STL (consulte http://www.sgi.com/tech/stl/sort.html o http://msdn.microsoft.com/en-us/library/ecdecxh1 (VS.80) .aspx ) o el antiguo C qsort: http://en.wikipedia.org/wiki/Qsort_(C_Standard_Library) . Aconsejaría no escribir su propio algoritmo de ordenación, a menos que sea una tarea de tarea. Su comparación depende de la tecnología que le gusta usar, podría hacer algo como esto:

int CompareCustomerProfile(
   const CustomerProfile* pC1,
   const CustomerProfile* pC2)
{
 int result = strcmp(pC1->name, pC2->name);
 if (0 != result) return result; 

  result = strcmp(pC1->ID, pC2->ID);
  if (0 != result) return result;

  if (pC1->amountDue < pC2->amountDue) return -1;
 if (pC1->amountDue > pC2->amountDue) return 1;

  return 0
}

esto supone que el tipo ''cadena'' en su ejemplo es un char *. Si usa tipos Unicode o multibyte, obviamente se debe usar la comparación Unicode o multibyte apropiada. Entonces solo llamarías al algoritmo, con tu función de comparación. P.ej. usando qsort:

qsort(c, Count, sizeof(CustomerProfile), CompareCustomerProfiler).

Ahora bien, si se trata de una tarea para casa, no deberías estar preguntando cómo hacerlo ...

Answer 5

Supongo que eres nuevo en programación o en C ++, así que aquí es lo que probablemente estés buscando:

#include <search.h> // for the qsort()

int
CompareByName( const void *elem1, const void *elem2 )
{
  return ((Customers*)elem1)->Name > ((Customers*)elem2)->Name? 1 : -1;
}

int
CompareByOrderAmount( const void *elem1, const void *elem2 )
{
  return ((Customers*)elem1)->OrderAmount > ((Customers*)elem2)->OrderAmount? 1 : -1;
}

void SortData( int SortItem, int count, Customers customers[] )
{
  switch (SortItem) {
  case 0:
    qsort(customers, count, sizeof(Customers), CompareByName);
    break;
  case 1:
    qsort(customers, count, sizeof(Customers), CompareByOrderAmount);
    break;
  // ...
  }
}

void test()
{
  Customers cust[10];

  cust[0].Name = "ten";
  cust[1].Name = "six";
  cust[2].Name = "five";
  SortData( 0, 3, cust );
  cout << cust[0].Name << endl;
  cout << cust[1].Name << endl;
  cout << cust[2].Name << endl;
}