具有枚举 Direction/Type 的冒泡排序结构数组

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

我在 compData 中为条件语句的 else 部分添加了 return false，它按预期工作。

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

您的比较功能大部分缺失，但存在的部分表明您无法return确定的false，这对于适当的比较器是强制性的。

其次，你调用的参数顺序是错误的。 "right" 边参数应该是 first，"left" 边是第二个。如果比较器的答案为真，则它们的顺序错误，应该交换。

解决这两个问题（并为您提供改进的冒泡排序，对已排序的序列进行早期退出检测），结果按预期运行：

#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

具有枚举 Direction/Type 的冒泡排序结构数组

Bubblesort Struct Array with Enumerated Direction/Type

c++

bubble-sort

enumerated-types