Sorting different sized cards in an array - c++

Question

I have been trying to work on this problem for quite some time but I seem to be stuck and not getting the results that are needed.
Lets say I want to stack some cards in my hand.
I have to use an array of structs, because each card has a name as well.
struct Creature {
std::string name;
int x, y;
};
In my main.cpp, I make the variable
Creature c[MAX_CARDS]
I can only hold 100 cards so MAX_CARDS is 100.
The thing is, there are only 10 unique cards. Each has their own name and their own size. Sizes like 2x6, 3x1, 4x2, 1x10, 8x4, 1x5, 6x2, etc...
The rule is that no card is bigger than the card below it. Sorted in a way of 'smallest' to largest. For example if card1 is 4x8 and card2 is 2x9, then these cards are unstackable, so they would get sorted to the end of the array, as it is possible for the next card drawn to be a card that could satisfy one of those cards and then be shuffled to the correct location in the array, same with cards with identical sizes for x and y, so repeats to the back. However, if card1 is 1x2 and card2 is 1x3 this can work and is stackable.
I hope that explain the logic of stackable cards, because that is the part i think im having trouble with.
template <typename T>
void sortArray(T c[], const int size) {
int positionOfMin, x1, x2, y1, y2;
T minValue, temp;
bool swap = false;
for (int i = 0; i < size; i++) {
minValue = c[i];
positionOfMin = i;
for (int j = i+1; j < size; j++) {
x1 = minValue.x;
y1 = minValue.y;
x2 = c[j].x;
y2 = c[j].y;
if(x1 < x2 && y1 < y2) {
swap = false;
}else if (((x1 > x2 && x1 > y2) || (y2 > x2 && y1 > y2)) ) {
swap = true;
}else if (x1 == x2 && y1 == y2){
swap = false;
}else{
swap = true;
}
if (swap == true) {
minValue = c[j];
positionOfMin = j;
}
}
// Swap the values to the new or same minimum value
temp = c[i];
c[i] = minValue;
c[positionOfMin] = temp;
}
}
Any ideas or help would be greatly appreciated, the results im getting are not correct at all.

Answer 1

Sort by (decreasing) {x, y}, they create a different stack once you encounter an unstackable card.
std::vector<std::vector<Card>> reorganize(std::vector<Card> cards)
{
std::sort(cards.begin(), cards.end(),
[](const Card& lhs, const Card& rhs){
return std::tie(rhs.width, rhs.height) < std::tie(lhs.width, lhs.height);
});
std::vector<std::vector<Card>> res;
for (const auto& card : cards) {
auto it = std::find_if(res.begin(), res.end(),
[&](const auto& stack) {
return card.height <= stack.back().height;
});
if (it == res.end()) {
res.push_back({card});
} else {
(*it).push_back(card);
}
}
return res;
}
Demo