C++ 数组中的函数排序错误

所以我想按不同的标准对数组进行排序，但问题来了，当两个项都有相同的值时，我想按名称排序。让我用一个例子来解释： 我有这个：

俄亥俄州49

威斯康星州46

肯塔基州46

这将是我的数据结构：

const int US_STATES = 51;
const int MAX_INFO = 5;

struct Info{
    double values;
    int units, shipments;
};

typedef Info TaulaQuarters[MAX_INFO];   //Where TaulaQuarters[0] és el total i TaulaQUarters[1..4] son els trimestres

struct Estat{
    string stateName,code;
    int population;
    TaulaQuarters taulaQuarters;
    int totalPopulation;
};

typedef Estat TaulaEstats[US_STATES];

威斯康星州和肯塔基州有相同的值，但我希望威斯康星州在肯塔基州之下，因为肯塔基州在字母顺序上比威斯康星州大。 让我向您展示我的主要排序操作：

bool esMajor (double n1, double n2, string nom1, string nom2, char criteri)
{
    //pre:
    //lpost:
        int enter1 = int(n1);
        int enter2 = int(n2);

        bool hoEs = false;
        if (criteri == 'v'){
            if (n1 > n2) hoEs = true;
            else if (n1 == n2){
                if (nom1 > nom2) hoEs = true;
            }
        }
        else if (criteri == 'u' or criteri == 's'){
            if (enter1 > enter2) hoEs = true;
            else if (enter1 == enter2){
                if (nom1 < nom2) hoEs = true;
            }
        }
        else if (criteri == 'n'){
            if (nom1 < nom2) hoEs = true;
        }
        //else if ()
        return hoEs;
}
void ordena (TaulaEstats taulaEstats, char criteri)
{
    //Pre:
    //post:
        //----Intializing----
        Estat aux; aux.code = "--"; aux.population = 0; aux.stateName = "--"; aux.totalPopulation = 0;
        for (int x = 0; x < 5; x++){
            aux.taulaQuarters[x].shipments = 0; aux.taulaQuarters[x].units = 0; aux.taulaQuarters[x].values = 0;
        }
        //-------END---------
        for (int i = 0; i < int(US_STATES);i++){
            int j = i;
            //if (criteri == 'v'){
                while (j > 0 and esMajor(taulaEstats[j].taulaQuarters[0].values,taulaEstats[j-1].taulaQuarters[0].values,taulaEstats[j].stateName, taulaEstats[j-1].stateName, criteri)){
                    aux = taulaEstats[j-1];
                    taulaEstats[j-1] = taulaEstats[j];
                    taulaEstats[j]= aux;
                    j--;
                }
            }
}

bool-esMajor（双n1，双n2，字符串名称1，字符串名称2，字符标准）
{
//前：
//lpost：
int enter1=int（n1）；
int enter2=int（n2）；
布尔-霍斯=假；
如果（标准=='v'）{
如果（n1>n2）hoEs=true；
否则如果（n1==n2）{
如果（nom1>nom2）hoEs=true；
}
}
否则如果（criteri='u'或criteri='s'）{
如果（enter1>enter2）hoEs=true；
否则如果（输入1==输入2）{
如果（nom1”aux.population=0；aux.stateName=“-->”aux.totalPopulation=0；
对于（int x=0；x<5；x++）{
aux.taulaQuarters[x]。发货量=0；aux.taulaQuarters[x]。单位=0；aux.taulaQuarters[x]。值=0；
}
//-------结束---------
对于（int i=0；i0和esMajor（taulaEstats[j].taulaEstats[0]。值，taulaEstats[j-1]。taulaEstats[0]。值，taulaEstats[j]。stateName，taulaEstats[j-1]。stateName，criteri））{
aux=taulaEstats[j-1]；
taulaEstats[j-1]=taulaEstats[j]；
taulaEstats[j]=aux；
j--；
}
}
}

其中，

esMajor

将根据标准告诉我第一个数字是否大于第二个数字，如果相等，将告诉我第一个名称是否大于第二个名称。 而

ordena

正是我对数组进行排序的算法

谢谢你的帮助，节日快乐

---

（抱歉我的英语）.< /p> 如果这是C++，你应该在结构中封装数字和名称，并为类重载比较运算符。

struct StateInfo
{
    std::string stateName; 
    int stateNumber;

public:
    StateInfo() : stateName("DEFAULTNAME"),stateNumber(0){}

    StateInfo(std::string name, int, number): stateName(name),stateNumber(number){}


    bool operator< (const StateInfo& rhs)
    {

        if( rhs.stateNumber==this->stateNumber) 
        {
            return rhs.stateName< this->stateName; //if numbers are equal compare by name
        } 
        return rhs.stateNumber<this->stateNumber; 
    } 

    //overload other operators as necessary


}

#include <vector>
#include <tuple>     // std::pair
#include <algorithm> // std::sort
#include <iterator>  // std::begin, std::end
#include <iostream>

using StateInfo   = std::pair<int, std::string>;
using CountryInfo = std::vector<StateInfo>;

int main()
{
    CountryInfo usa_info {{49, "Ohio"}, {46, "Wisconsin"}, {46, "Kentucky"}};

    std::sort(std::begin(usa_info), std::end(usa_info));

    for (const auto& d : usa_info) std::cout << d.second << " " << d.first << std::endl;

    return 0;
}

struct StateInfo
{
std：：字符串stateName；
国家编号；
公众：
StateInfo（）：stateName（“DEFAULTNAME”），stateNumber（0）{}
StateInfo（std:：string name，int，number）：stateName（name），stateNumber（number）{}
布尔运算符<（常数状态信息和rhs）
{
如果（rhs.stateNumber==此->stateNumber）
{
返回rhs.stateNamestateName；//如果数字相等，请按名称进行比较
} 
返回rhs.stateNumberstateNumber；
} 
//必要时使其他操作员过载
}

现在，您可以使用

std:：sort

from

#include

对放入容器（如

std:：vector

）中的所有对象进行排序

解决方案的要点是让std:：sort知道如何比较结构的两个不同实例。当std:：sort知道这一点时，它可以为您进行排序

走阵列路线非常混乱，不建议这样做

---

如果您对自己的排序算法或插入排序、合并排序、QuasL排序等有兴趣，那么您仍然可以使用重载操作符> <= = >来编写自己的排序算法。

< P>如果您是C++，则应该在结构中封装数字和名称，并为CL重载比较运算符。像这样：

struct StateInfo
{
    std::string stateName; 
    int stateNumber;

public:
    StateInfo() : stateName("DEFAULTNAME"),stateNumber(0){}

    StateInfo(std::string name, int, number): stateName(name),stateNumber(number){}


    bool operator< (const StateInfo& rhs)
    {

        if( rhs.stateNumber==this->stateNumber) 
        {
            return rhs.stateName< this->stateName; //if numbers are equal compare by name
        } 
        return rhs.stateNumber<this->stateNumber; 
    } 

    //overload other operators as necessary


}

#include <vector>
#include <tuple>     // std::pair
#include <algorithm> // std::sort
#include <iterator>  // std::begin, std::end
#include <iostream>

using StateInfo   = std::pair<int, std::string>;
using CountryInfo = std::vector<StateInfo>;

int main()
{
    CountryInfo usa_info {{49, "Ohio"}, {46, "Wisconsin"}, {46, "Kentucky"}};

    std::sort(std::begin(usa_info), std::end(usa_info));

    for (const auto& d : usa_info) std::cout << d.second << " " << d.first << std::endl;

    return 0;
}

struct StateInfo
{
std：：字符串stateName；
国家编号；
公众：
StateInfo（）：stateName（“DEFAULTNAME”），stateNumber（0）{}
StateInfo（std:：string name，int，number）：stateName（name），stateNumber（number）{}
布尔运算符<（常数状态信息和rhs）
{
如果（rhs.stateNumber==此->stateNumber）
{
返回rhs.stateNamestateName；//如果数字相等，请按名称进行比较
} 
返回rhs.stateNumberstateNumber；
} 
//必要时使其他操作员过载
}

现在，您可以使用

std:：sort

from

#include

对放入容器（如

std:：vector

）中的所有对象进行排序

解决方案的要点是让std:：sort知道如何比较结构的两个不同实例。当std:：sort知道这一点时，它可以为您进行排序

走阵列路线非常混乱，不建议这样做

---

如果您有兴趣制定自己的排序算法或练习插入排序、合并排序、快速排序等，那么您仍然可以使用重载运算符><==编写自己的排序算法。

如果两个数字相同，您只需取其名称，然后应用此算法即可

if(name1[0]>name2[0]){
    //Name1 is alphabetically greater place it first in the queue
}
else if(name1[0]<name2[0]){
    //Name2 is alphabetically greater place it first in the queue
}
else{
    //Both are equal. Do what you want.
}

if（name1[0]>name2[0]）{
//名称1的字母顺序更大，将其放在队列的第一位
}
否则如果（name1[0]如果两个数字相同，则只需取它们的名称，然后应用此算法即可

if(name1[0]>name2[0]){
    //Name1 is alphabetically greater place it first in the queue
}
else if(name1[0]<name2[0]){
    //Name2 is alphabetically greater place it first in the queue
}
else{
    //Both are equal. Do what you want.
}

if（name1[0]>name2[0]）{
//名称1的字母顺序更大，将其放在队列的第一位
}
否则，如果（name1[0]您的代码有点像雷区，但您可以通过以下方式实现所需：

struct StateInfo
{
    std::string stateName; 
    int stateNumber;

public:
    StateInfo() : stateName("DEFAULTNAME"),stateNumber(0){}

    StateInfo(std::string name, int, number): stateName(name),stateNumber(number){}


    bool operator< (const StateInfo& rhs)
    {

        if( rhs.stateNumber==this->stateNumber) 
        {
            return rhs.stateName< this->stateName; //if numbers are equal compare by name
        } 
        return rhs.stateNumber<this->stateNumber; 
    } 

    //overload other operators as necessary


}

#include <vector>
#include <tuple>     // std::pair
#include <algorithm> // std::sort
#include <iterator>  // std::begin, std::end
#include <iostream>

using StateInfo   = std::pair<int, std::string>;
using CountryInfo = std::vector<StateInfo>;

int main()
{
    CountryInfo usa_info {{49, "Ohio"}, {46, "Wisconsin"}, {46, "Kentucky"}};

    std::sort(std::begin(usa_info), std::end(usa_info));

    for (const auto& d : usa_info) std::cout << d.second << " " << d.first << std::endl;

    return 0;
}

#包括
#include//std:：pair
#include//std:：sort
#包括//标准：：开始，标准：：结束
#包括
使用StateInfo=std:：pair；
使用CountryInfo=std:：vector；
int main（）
{
CountryInfo usa_info{{49，“俄亥俄州”}、{46，“威斯康星州”}、{46，“肯塔基州”}；
标准：：排序（标准：：开始（美国信息），标准：：结束（美国信息））；
法罗群岛