Dual selection sorting an array - honestly stumped - c++

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);
}
I am required to use the selection sort or bubble sort algorithm.
I have Bank Account Numbers that have to be correspondingly and ascending sorted with there Account Balance, all the data is read from a file.
After sorting the data I have to rewrite it into another file, which is the least of my worries.
So the question is how do I go about sorting my accountNumbers in ascending order along with their accountBalance following them.

Answer 1

You need to sort according to accountNumbers but apply every swap operation to both arrays.
Here is the code using selection sort:
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 2

You can declare a struct:
struct Account{
int accountNum;
int accountBalance;
bool operator<(const Account& a);
};
Then overload the comparison operator:
bool Account::operator<(const Account& a);
{
return (accountNum < a.accountNum);
}
Then put all your data in a struct vector using for loops:
std::vector<Account> accVec;
Finally sort vector using std::sort()
std::sort(accVec.begin(), accVec.end());
Now you have your data neatly stored in a vector in ascending order of account number.
Alternatively you can apply regular bubbleSort to sort the elements, as shown by "abcOfJavaAndCPP"
for(int j = 1; j < accVec.size(); ++j)
for(int i = 1; i < accVec.size() ; ++i)
if(accVec[i-1] < accVec[i])
std::swap(accVec[i], accVec[i+1]);

Answer 3

to do bubble sort algorithm you must do 2 for loops and a temporary variable
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;
}
just implement this to your function that do the bubble sort

Answer 4

Code can be simplified quite a bit by using some more modern C++ techniques:
#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);
}
Would encourage you to learn about classes, or even just structs to start, and also get familiar with std::vector as you should be using it a lot.