Как я могу отсортировать вектор на основе другого вектора?

Question

У меня есть четыре вектора, которые я хочу отсортировать по отношению друг к другу.

vector<string> color;
vector<string> shape;
vector<int> size;

Каждый вектор имеет одинаковый размер, каждый элемент вектора привязан друг к другу так, что он образует строку

{color[0], shape[0], size[0]}
{color[1], shape[1], size[1]}
{color[2], shape[2], size[2]}, etc

Итак, я пытаюсь отсортировать цветовой вектор по цвету и сортировать два других вектора на основе переставленного цветового вектора. Затем внутри каждой группы цветов (т.е. красного) я хочу отсортировать по форме и переставить вектор размера на основе этого вида. И, наконец, я хочу отсортировать вектор размера в каждой группе цвета и формы. Я думаю, что знаю, как это сделать, но мне кажется, что это очень, очень грязно и трудно осмыслить / прочитать (я все еще новичок в C ++). Есть ли простой способ сделать sh что-то вроде этого?

Например, я хочу сделать что-то вроде этого:

Blue    Circle      1   ->    Red   Triangle    1           
Red     Triangle    1   ->    Red   Triangle    2
Blue    Circle      3   ->    Red   Triangle    3
Red     Triangle    3   ->    Red   Circle      1
Red     Circle      2   ->    Red   Circle      2
Blue    Triangle    1   ->    Red   Circle      3
Red     Circle      1   ->    Blue  Triangle    1
Blue    Triangle    3   ->    Blue  Triangle    2
Red     Circle      3   ->    Blue  Triangle    3
Blue    Circle      2   ->    Blue  Circle      1
Blue    Triangle    2   ->    Blue  Circle      2
Red     Triangle    2   ->    Blue  Circle      3

Answer 1

Вы должны создать один Shape класс или структуру, а затем создать std::vector<Shape>, который затем можно будет отсортировать по цвету, в первую очередь, а затем другие параметры. Вы определяете перегруженный operator< так, чтобы функция std::sort находила его.

Это выглядело бы так:

#include <algorithm>
#include <iostream>
#include <string>
#include <tuple>
#include <vector>

struct Shape
{
    std::string color_;
    std::string shape_;
    int size_;

    Shape(const std::string& color, const std::string& shape, int size)
        : color_(color)
        , shape_(shape)
        , size_(size)
    {}

    // returns true if this shape is less than the other shape
    // "less than" is up to us: here we give priority to color, then shape, then size
    bool operator<(const Shape& other) const
    {
        // std::tie makes lexicographical compare of complex structures easy!
        return (std::tie(color_, shape_, size_) <
                std::tie(other.color_, other.shape_, other.size_));
    }

    friend std::ostream& operator<<(std::ostream& os, const std::vector<Shape>& shapes)
    {
        for (auto& shape : shapes)
        {
            os << shape.color_ << " " << shape.shape_ << " " << shape.size_ << "\n";
        }

        return os;
    }
};

int main(int argc, char** argv)
{
    std::vector<Shape> shapes;

    shapes.emplace_back("Blue", "Circle", 1);
    shapes.emplace_back("Red", "Triangle", 1);
    shapes.emplace_back("Blue", "Circle", 3);
    shapes.emplace_back("Red", "Triangle", 3);
    shapes.emplace_back("Red", "Circle", 2);
    shapes.emplace_back("Blue", "Triangle", 1);
    shapes.emplace_back("Red", "Circle", 1);
    shapes.emplace_back("Blue", "Triangle", 3);
    shapes.emplace_back("Red", "Circle", 3);
    shapes.emplace_back("Blue", "Circle", 2);
    shapes.emplace_back("Blue", "Triangle", 2);
    shapes.emplace_back("Red", "Triangle", 2);

    std::cout << "Pre sorted vector:\n";
    std::cout << shapes;

    // std::sort by default will use the operator< for the types
    // being sorted, if it's available
    std::sort(shapes.begin(), shapes.end());

    std::cout << "\nPost sorted vector:\n";
    std::cout << shapes;
}

Это дает вывод:

Pre sorted vector:
Blue Circle 1
Red Triangle 1
Blue Circle 3
Red Triangle 3
Red Circle 2
Blue Triangle 1
Red Circle 1
Blue Triangle 3
Red Circle 3
Blue Circle 2
Blue Triangle 2
Red Triangle 2

Post sorted vector:
Blue Circle 1
Blue Circle 2
Blue Circle 3
Blue Triangle 1
Blue Triangle 2
Blue Triangle 3
Red Circle 1
Red Circle 2
Red Circle 3
Red Triangle 1
Red Triangle 2
Red Triangle 3

Answer 2

Как и Джон указал, вы должны сделать один struct, а затем сделать std::vector, который затем можно отсортировать по цвету. Вот решение:

#include <iostream>
#include <vector>
#include <algorithm> 
#include <cctype> 

struct MyStruct
{
    std::string color;
    std::string shape;
    int size;

    MyStruct(std::string co, std::string sh, int si): 
        color{co}, shape{sh}, size{si} {};
};

bool MyComp(MyStruct a,MyStruct b)
{ 
    auto f = [](unsigned char c){ return std::tolower(c);};
    std::transform(a.color.begin(), a.color.end(), a.color.begin(),f);
    std::transform(b.color.begin(), b.color.end(), b.color.begin(),f);

    return (a.color < b.color); 
}

int main() {

    std::vector<MyStruct> MyVec;

    MyVec.emplace_back("Blue","Circle",1); 
    MyVec.emplace_back("Red","Triangle",1);  
    MyVec.emplace_back("Blue","Circle",3);
    MyVec.emplace_back("Red","Triangle",3);   
    MyVec.emplace_back("Red","Circle",2);  
    MyVec.emplace_back("Blue","Triangle",1);   
    MyVec.emplace_back("Red","Circle",1);   
    MyVec.emplace_back("Blue","Triangle",3);   
    MyVec.emplace_back("Red","Circle",3);  
    MyVec.emplace_back("Blue","Circle",2);  
    MyVec.emplace_back("Blue","Triangle",2);   
    MyVec.emplace_back("Red","Triangle",2);

    std::sort(MyVec.begin(), MyVec.end(), MyComp);

    for(auto s : MyVec)
        std::cout << s.color << " " << s.shape  << " " << s.size << std::endl; 

    return 0;
}

Вы можете запустить код онлайн , чтобы увидеть следующий вывод:

Blue Circle 1
Blue Circle 3
Blue Triangle 1
Blue Triangle 3
Blue Circle 2
Blue Triangle 2
Red Triangle 1
Red Triangle 3
Red Circle 2
Red Circle 1
Red Circle 3
Red Triangle 2

Answer 3

Первое решение

Один из способов решения проблемы - , а не сортировка векторов, а вместо этого создание нового вектора индексов, назовем его I, так что элементы в позиции j в отсортированных векторах находятся в позиции I[j] в текущих несортированных векторах.

Этот индексный вектор легко создать, инициализируя его возрастающими значениями 0 .. n-1 и сортировка вектора с помощью пользовательской функции сравнения:

std::vector<int> I(N);
std::iota(begin(I), end(I), 0);
std::sort(begin(I), end(I), [&](int ia, int ib) { return color[ia] < color[ib]; });
// this is a simplified comparison function to not clutter the code

Теперь, если вы хотите получить доступ к shape 3-го элемента в последовательности, отсортированной по color, вы пишете:

auto shape3 = shape[I[3]];

Второе решение

Первое решение работает, но оно может не понравиться по многим причинам. Возможно, вам не нравится тот факт, что он рандомизирует доступ к памяти (и связанный штраф), когда вы проходите элементы в порядке возрастания. Или, может быть, вам действительно нужно отсортировать векторы, потому что вы должны передать их другому компоненту.

В этом случае вы все равно можете использовать первый метод в качестве первого шага, а затем переупорядочить векторы на основе индексов только что вычислил Вот пример такого переупорядочения для вектора shape:

std::vector<std::string> tmp_shape;
tmp_shape.reserve(N);
for(int j=0; j<N; ++j)
    tmp_shape.emplace_back(std::move(shape[I[j]]));
shape.swap(tmp_shape);

Очевидно, вам нужно сделать это для трех векторов, чтобы сохранить их связь.