Question

void dualSort(int [], double [], int);
int main()
{
    const int ARRAY_SIZE = 1000;            // Array size
    double accountNumbers[ARRAY_SIZE];      // Array with 1000 elements
    double accountBalances[ARRAY_SIZE];     // Loop counter variable
    int count = 0;                              // Input file stream object
    ifstream inputFile;

    // Open the file.
    inputFile.open("FinalNumbers.txt");

    // Read the numbers from the file into the array
    while (count < ARRAY_SIZE && inputFile >> accountNumbers[count] >> accountBalances[count] ) {
        count++;
    }

    inputFile.close();

    // Display the read data
    cout << "The bank account numbers are: " << endl;
    for (int count = 0; count < ARRAY_SIZE; count++) {
        cout << accountNumbers[count] << "\n" << accountBalances[count] << " " << endl;
    }

    void dualSort(int accountNumbers[], double accountBalances, int ARRAY_SIZE);



}

我需要使用选择排序或冒泡排序算法。

我银行帐号必须相应地按升序排序帐户余额，所有数据都从文件中读取。

对数据进行排序后，我必须将其重写为另一个文件，这是我最不担心的事情。

所以问题是如何按升序排序我的accountNumbers以及跟随他们的accountBalance。

Answer 1

要做冒泡排序算法，你必须做2 for个循环和一个临时变量

int tempAccNumber=0;
int tempAccBalance=0;
for(int j=0;j<ARRAY_SIZE-1;++j)
    for(int i=0;i<ARRAY_SIZE-1;++i)
          if(accountNumbers[i]>accountNumbers[i+1])
          {             
              tempAccNumber=accountNumbers[i];
              accountNumbers[i]=accountNumbers[i+1];
              accountNumbers[i+1]=tempAccNumber;
              tempAccBalance=accountBalances[i];
              accountBalances[i]=accountBalances[i+1];
              accountBalances[i+1]=tempAccBalance;
          }

只需将此功能实现到执行冒泡排序的函数

Answer 2

您可以声明一个结构：

Error in `/.difftime`(w, w2) : 
  second argument of / cannot be a "difftime" object

然后重载比较运算符：

struct Account{
    int accountNum;
    int accountBalance;
    bool operator<(const Account& a);
};

然后使用for循环将所有数据放入结构向量中：

bool Account::operator<(const Account& a);
{
    return (accountNum < a.accountNum);
}

最后使用std :: sort（）

对矢量进行排序

std::vector<Account> accVec;

现在，您可以按照帐号的升序将数据整齐地存储在矢量中。

或者，您可以应用常规bubbleSort对元素进行排序，如“abcOfJavaAndCPP”所示

std::sort(accVec.begin(), accVec.end());

Answer 3

您需要根据accountNumbers排序，但将每个交换操作应用于两个数组。

以下是使用选择排序的代码：

void dualSort(int accountNumbers[], double accountBalances[], int ARRAY_SIZE)
{
 int minIndex;

 for(int i = 0; i < ARRAY_SIZE - 1; i++)
 {
  minIndex = i;

  for(int j = i + 1; j < ARRAY_SIZE; j++)
  {
   if(accountNumbers[j] < accountNumbers[minIndex])
   {
    minIndex = j;
   }
  }

  swap(accountNumbers[i], accountNumbers[minIndex]);
  swap(accountBalances[i], accountBalances[minIndex]);
 }
}

Answer 4

使用一些更现代的C ++技术可以简化代码：

#include <vector>

struct Account {
    double balance;
    int number;
};

bool operator<(const Account& lhs, const Account& rhs) {
    return lhs.number < rhs.number;
}

void dualSort(vector<Account>& v) {
    for (std::size_t i = 0; i != v.size() - 1; ++i) {
        for (std::size_t j = 0; j != v.size() - 1; ++j) {
            if (v[j] < v[j+1]) std::swap(v[j], v[j+1]);
        }
    }
}

int main()
{
    const int ARRAY_SIZE = 1000;            // Array size
    std::vector<Account> v(ARRAY_SIZE);
    std::ifstream inputFile;

    // Open the file.
    inputFile.open("FinalNumbers.txt");

    for (std::size_t i = 0; i != ARRAY_SIZE; ++i) {
        inputFile >> v[i].number >> v[i].balance;
    }

    inputFile.close();

    // Display the read data
    cout << "The bank account numbers are: " << endl;
    for (int count = 0; count < ARRAY_SIZE; count++) {
        cout << v[count].number << "\n" << v[count].balance << " " << endl;
    }

    void dualSort(v);
}

鼓励你学习课程，甚至只是开始学习结构，并且熟悉std::vector，因为你应该经常使用它。

双选择排序阵列 - 老老实实地难倒

4 个答案: