blocks|key|3371695|text|我不知道你的容器类型是什么，所以我假设是std::string。最简单的事情可能是创建一个单独的tuples的vector：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3371696|using+StrTuple+=+std::tuple<std::string*,+std::string*,+std::string*>;
std::vector<StrTuple>+combined;
for+(size_t+i+=+0;+i+<+_category.size();+%2B%2Bi)+{
++++combined.emplace_back(&_category[i],+&_description[i],+&_price[i]);
}|code-block|syntax|javascript|3371697|然后按类别对其进行排序：|3371698|std::sort(std::begin(combined),+std::end(combined),
++++++++++[](const+StrTuple&+lhs,+const+StruTuple&+rhs)+{
++++++++++++++return+*std::get<0>(lhs)+<+*std::get<0>(rhs);
++++++++++});|3371699|然后按顺序流传输：|3371700|for+(auto&+t+:+combined)+{
++++menuFile+<<+*std::get<0>(t)+<<+":"+<<+*std::get<1>(t)+<<+":"+<<+*std::get<2>(t)+<<+std::endl;
}|3371701|同样，也可以使用单独的类型来实现，例如：|3371702|struct+CombinedValues+{
++++std::string+*category,+*description,+*price;
};|3371703|entityMap^0|K|B|1C|5|1J|6|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1A|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|X|$]]

I don't know what your container types are, so I'm going to assume <code>std::string</code>. The simplest thing might be to just make a separate <code>vector</code> of <code>tuple</code>s:

<pre><code>using StrTuple = std::tuple&lt;std::string*, std::string*, std::string*&gt;;
std::vector&lt;StrTuple&gt; combined;
for (size_t i = 0; i &lt; _category.size(); ++i) {
 combined.emplace_back(&amp;_category[i], &amp;_description[i], &amp;_price[i]);
}
</code></pre>

And then sort that one by category:

<pre><code>std::sort(std::begin(combined), std::end(combined),
 [](const StrTuple&amp; lhs, const StruTuple&amp; rhs) {
 return *std::get&lt;0&gt;(lhs) &lt; *std::get&lt;0&gt;(rhs);
 });
</code></pre>

And then just stream it in order:

<pre><code>for (auto&amp; t : combined) {
 menuFile &lt;&lt; *std::get&lt;0&gt;(t) &lt;&lt; ":" &lt;&lt; *std::get&lt;1&gt;(t) &lt;&lt; ":" &lt;&lt; *std::get&lt;2&gt;(t) &lt;&lt; std::endl;
}
</code></pre>

The same could be achieved with a separate type instead, something like:

<pre><code>struct CombinedValues {
 std::string *category, *description, *price;
};
</code></pre>

blocks|key|3371757|text|我认为您应该创建一个结构来处理这三种类型的数据，然后为它创建一个向量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3371758|例如：|3371759|struct+Menu+{
++++string+category;
++++string+description;
++++int+price;
};|code-block|syntax|javascript|3371760|然后，我建议您实现一个比较器来决定如何对数据进行排序。假设按价格排序(当然，您可以决定如何实现重载操作符)。|3371761|struct+Menu+{
++++string+category;
++++string+description;
++++int+price;
++++bool+operator+<+(const+Menu&+rhs)+const+{
++++++++return+(this->price+<+rhs.price);
++++}
};|3371762|然后，只需为该结构创建一个向量并对其进行排序。|3371763|vector<Menu>+menu;
//+do+something,+insert+data
sort(menu.begin(),menu.end());|3371764|然后相应地输出。|3371765|for(int+x+=+0;+x+<+menu.size();+x%2B%2B){
++++menuFile+<<+menu[x].category+<<+":"+<<+menu[x].description+<<+":"+<<+menu[x].price+<<+endl;
}++|3371766|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

I believe you should create a struct to handle the three types of data and then make a vector for it.

for example:

<pre><code>struct Menu {
 string category;
 string description;
 int price;
};
</code></pre>

then i would recommend you to implement a comparator to decide on how to sort the data. Let's say sort by the price (You can decide on how to implement the overloaded operator of course).

<pre><code>struct Menu {
 string category;
 string description;
 int price;
 bool operator &lt; (const Menu&amp; rhs) const {
 return (this-&gt;price &lt; rhs.price);
 }
};
</code></pre>

then just make a vector for this struct and sort it.

<pre><code>vector&lt;Menu&gt; menu;
// do something, insert data
sort(menu.begin(),menu.end());
</code></pre>

Then output accordingly.

<pre><code>for(int x = 0; x &lt; menu.size(); x++){
 menuFile &lt;&lt; menu[x].category &lt;&lt; ":" &lt;&lt; menu[x].description &lt;&lt; ":" &lt;&lt; menu[x].price &lt;&lt; endl;
} 
</code></pre>

blocks|key|3371803|text|我不认为有更有效的算法来做到这一点。你可能会这样想，因为你用同样的东西做了4次循环。但是你仍然在做O(n)效率。添加一个类似上面的命题的排序操作将增加一个以O(n*log(n))效率运行的步骤，这要糟糕得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3371804|您仍然需要4个循环，所以我们唯一可以尝试优化的就是测试，即用更快的东西替换每个循环中的字符串比较()操作。可以用整数测试替换字符串测试，这意味着预先计算新向量中的类别号(即，如果category==是“Starter”，则为0；如果是"Main"，则为1；如果不是任何感兴趣的类别，则为0..3+(如果这是可能的))|3371805|这将意味着计算此类别的初始循环，这可以使其更有效(使用平均2个字符串比较)。或者甚至更少地使用类别字符串的散列映射。|3371806|因此，在循环中，我们只对每个元素进行整数比较，而不是字符串比较。但是，我们在第一个循环中添加了计算类别号的时间。乍一看，哪个更快并不明显:4个循环和4*n个字符串比较或4个循环，2*n个字符串比较和4*n个整数比较。如果比较字符串比比较整数的开销大得多，这可能会更快。|3371807|对于这类东西，唯一知道的方法就是测量实际的执行时间。显然，所有这一切都很耗时，所以只有在确实有必要的时候才这样做(例如，分析器告诉您这部分需要优化)。|3371808|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

I do not think there is a much more efficient algorithm to do that. You may think so because you do 4 loop with the same thing. But you are still doing O(n) efficiency. Adding a sort operation like some proposition above would add a step running at O(n*log(n)) efficiency, which is way worse.

You still need the 4 loops, so the only thing we can try to optimize is the testing, that is replacing the string compare() operation in each loop by something faster. Something possible would be to replace the string test by an integer test, meaning pre-computing a category number in a new vector (i.e. a value 0 if category=="Starter", 1 if "Main", etc and a value different from 0..3 if not any of the interesting category (if that is possible)

That would mean an initial loop to compute this category, which can be made more efficient (using an average of 2 string comparison). Or even less using a hash map of the category string.

So in the loops, we just do an integer comparison instead of a string comparison for each element. However, we add the time to compute the category number in the first loop. It is not obvious at first glance which will be faster: 4 loops and 4*n string comparisons or 4 loops, 2*n string comparisons and 4*n integer comparisons. That may be faster, if comparing strings are much more costly than comparing integers.

For this kind of stuff, only way to know is to measure actual execution time. Obviously, all this is time consuming, so only to be done if this is really necessary (i.e. your profiler tells you that this part needs to be optimized)

I have 3 vectors, <code>category</code> <code>description</code> and <code>price</code> I have written this piece of code to put the vectors organised by <code>category</code> into a file called <code>menuFile</code>:

<pre><code>for(int x = 0; x &lt; _category.size(); x++){
 if(_category[x].compare("Starter") == 0){
 menuFile &lt;&lt; _category[x] &lt;&lt; ":" &lt;&lt; _description[x] &lt;&lt; ":" &lt;&lt; _price[x] &lt;&lt; endl;
 }
}

for(int x = 0; x &lt; _category.size(); x++){
 if(_category[x].compare("Main") == 0){
 menuFile &lt;&lt; _category[x] &lt;&lt; ":" &lt;&lt; _description[x] &lt;&lt; ":" &lt;&lt; _price[x] &lt;&lt; endl;
 }
}

for(int x = 0; x &lt; _category.size(); x++){
 if(_category[x].compare("Pudding") == 0){
 menuFile &lt;&lt; _category[x] &lt;&lt; ":" &lt;&lt; _description[x] &lt;&lt; ":" &lt;&lt; _price[x] &lt;&lt; endl;
 }
}

for(int x = 0; x &lt; _category.size(); x++){
 if(_category[x].compare("Drink") == 0){
 menuFile &lt;&lt; _category[x] &lt;&lt; ":" &lt;&lt; _description[x] &lt;&lt; ":" &lt;&lt; _price[x] &lt;&lt; endl;
 }
} 
</code></pre>

But this does not seem like a very efficient method. Is the a better way to do this?

Efficient sorting algorithm for 3 vectors

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有3个向量，category，description和price我写了这段代码，将category组织的向量放到一个名为menuFile的文件中for(int x = 0; x < _category.size(); x++){ if(_category[x].compare("Starter") == 0){...

问一种高效的三向量排序算法
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问一种高效的三向量排序算法EN