Question

我有一个函数排序，正在传递一个结构数组。

结构包含字符串。

struct studentStruct {                                                                                                                      
  string firstName;
  string lastName;
  int grade;
  float GPA;
};

我正在将该结构数组以及2个枚举类型传递给排序函数。

enum sortField {eFirstName, eLastName, eGrade, eGPA};                                                                                                   
enum sortDirection {eAscending, eDescending};

现在，我必须使用Bubblesort和compData函数，因此；

void sort( studentStruct s[], enum sortField field, int length, sortDirection d)
{
  for(int i = 0; i < length - 1; i++)
    {
      for(int j = 0; j < length - 1 - i; j++)
        {
          if(compData(s[j], s[j+1], field, d) == true)
            {
              swap(s[j], s[j+1]);
              cout << "SWAP" << endl;
            }
        }
    }
}
bool compData( studentStruct s1, studentStruct s2,  sortField field, sortDirection direction)
{
  switch(field)
    {
    case eFirstName:
      {
        string f1 = s1.firstName;
        string f2 = s2.firstName;
        switch(direction)
          {
          case eAscending:
            {
              if(f2 < f1)
                return true;
            }
          case eDescending:
            {
              if(f2 > f1)
                return true;
            }
          }
      }
    }
}

所以；我通过对Structs s[]的数组进行排序，它调用compData来决定是否切换s[j]和s[j+1]。 compData查看枚举值，以确定我们如何比较s[j]和s[j+1]，选择对eFirstName，eAscending进行排序，然后进行相应的排序。

但是实际上，我通过了sort(s[], eFirstName, 10, eAscending)，并且得到了错误分类的混乱。对于M, I, K, O, N,的5个输入，我要离开 N, O, K, I, M;只是翻转数组。

Answer 1

我在return false中的条件语句的else部分中添加了compData，它可以正常工作。

switch(direction)
{
    case eAscending:
    {
        if(f2 < f1)
            return true;
        else    
            return false;
    }
    case eDescending:
    {
        if(f2 > f1)
            return true;
        else    
            return false;
    }
}

在线查看demo。

Answer 2

您的比较功能大部分都丢失了，但是那里的部分表明您没有返回绝对的false的路径，这对于适当的比较器是必不可少的。

第二，您调用参数的顺序是错误的。 “右侧”自变量应为 first ，“左侧”应为第二。如果比较器回答为“是”，则它们的顺序错误，应将其交换。

同时解决这两个问题（并通过对已排序序列的早期退出检测为您提供改进的冒泡排序），结果将按预期发挥作用：

#include <iostream>
#include <algorithm>

enum sortField {eFirstName, eLastName, eGrade, eGPA};
enum sortDirection {eAscending, eDescending};

struct studentStruct {
    std::string firstName;
    std::string lastName;
    int grade;
    float GPA;
};

bool compData( studentStruct s1, studentStruct s2, sortField field, sortDirection direction)
{
    bool result = false;

    switch(field)
    {
        case eFirstName:
            switch(direction)
            {
                case eAscending:
                    result = s1.firstName < s2.firstName;
                    break;

                case eDescending:
                    result = s2.firstName < s1.firstName;
                    break;
            }
            break;

        case eLastName:
            switch(direction)
            {
                case eAscending:
                    result = s1.lastName < s2.lastName;
                    break;

                case eDescending:
                    result = s2.lastName < s1.lastName;
                    break;
            }
            break;

        case eGrade:
            switch(direction)
            {
                case eAscending:
                    result = s1.grade < s2.grade;
                    break;

                case eDescending:
                    result = s2.grade < s1.grade;
                    break;
            }
            break;

        case eGPA:
            switch(direction)
            {
                case eAscending:
                    result = s1.GPA < s2.GPA;
                    break;

                case eDescending:
                    result = s2.GPA < s1.GPA;
                    break;
            }
            break;
    }

    return result;

}

void sort( studentStruct s[], enum sortField field, int length, sortDirection d)
{
    bool swapped = true;
    while (swapped && length-- > 0)
    {
        swapped = false;
        for (int i=0; i<length; ++i)
        {
            if (compData(s[i+1], s[i], field, d))
            {
                std::cout << "SWAP" << '\n';
                std::swap(s[i+1], s[i]);
                swapped = true;
            }
        }
    }
}

int main()
{
    studentStruct students[] = { {"M"}, {"I"}, {"K"}, {"O"}, {"N"} };
    sort(students, eFirstName, 5, eAscending);

    for (auto const& s : students)
        std::cout << s.firstName << '\n';
}

输出

SWAP
SWAP
SWAP
I
K
M
N
O

具有枚举方向/类型的Bubblesort结构数组

2 个答案: