6
votes

Comment puis-je stocker 3 entier en priority_queue?

Je veux stocker 3 entier en priority_queue. Je sais comment stocker 2 entier. Je stocke 2 entier avec paire

mon code xxx

mais je ne sais pas comment puis-je stocker 3 entier . J'ai besoin d'aide.

Désolé pour mon anglais.


                        
                        
                            
                                                                    c++
                                                                    data-structures
                                                                    priority-queue
                                                            
                        
                                                    
                            
                            
                                1 commentaires
                                
                                                                            Je suppose que vous pouvez utiliser  paire >  pour stocker 3 entiers, mais ce serait idiot. : P



                                    
                    3 Réponses :
                    
                                            
                            
                                
                                    3
 votes
                                
                            
                            
                                
                                     Vous pouvez utiliser  boost :: tuple  a > 
#include "boost/tuple/tuple.hpp"
#include <queue>
#include <vector>
#include <iostream>

typedef boost::tuple<int, int, int> triple_t;

class my_greater  {
public:
  bool operator() (const triple_t& arg1, const triple_t& arg2) const
  {
    return arg1.get<0>() > arg2.get<0>();
    return false;
  }
};

typedef std::priority_queue<triple_t, std::vector<triple_t>, my_greater> 
   my_priority_queue;

int main()
{
  my_priority_queue triples;

  triples.push(boost::make_tuple(1,2,3));
  triples.push(boost::make_tuple(10,20,30));
  triples.push(boost::make_tuple(5,10,15));
  triples.push(boost::make_tuple(15,30,45));
  triples.push(boost::make_tuple(2,4,6));

  std::cout << "Result: \n";
  while (!triples.empty()) 
  {
    const triple_t& t = triples.top();
    std::cout << t.get<0>() << ", " << t.get<1>() << ", " << t.get<2>() << std::endl;
    triples.pop();
  }

  return 0;
}

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    8
 votes
                                
                            
                            
                                
                                     Le plus simple serait créer un  struct  qui lie logiquement tous les entiers et crée une file d'attente prioritaire de ces objets de structure. 
  edit 
Code exemple:   xxx                                  


                                                                    
                                    
                                    
                                        4 commentaires
                                        
                                                                                            
                                                     Opérateur << / Code> Ou un fonctionnement de comparaison devrait être spécifié pour  priority_queue  pour fonctionner avec cette structure.                                                

                                                
                                                                                            
                                                    Je crée la structure mais je ne peux pas pousser les entiers. Comment puis-je pousser les entiers?                                                
                                                
                                                                                            
                                                    Puisque la file d'attente prioritaire trie les éléments afin que le plus grand soit toujours le premier. Dans mon opérateur de comparaison  opérateur << / code> de  struct s  J'ai comparé les éléments basés sur le  int m_n1; . Depuis les 3 structures, j'ai ajouté à la file d'attente  S (4,2,3)  a la valeur la plus élevée pour cet entier, il vient d'abord.                                                

                                                
                                                                                            
                                                    @Elmi: Vous voudrez peut-être faire un  lexicographique  comparer. C'est le type de comparaison avec STD :: paire. Découvrez  Stackoverflow.com/Questtions/2500664 .                                                

                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    5
 votes
                                
                            
                            
                                
                                     ou le moyen facile:  std :: paire >                                   


                                                                    
                                    
                                    
                                        3 commentaires
                                        
                                                                                            
                                                    -1  triplet.second.second  est une manière terriblement laide et convoluée d'accéder au troisième élément du triplet. Cette solution n'apparaît pas du tout.                                                

                                                
                                                                                            
                                                    Il ne devrait pas être à l'échelle et de toute façon n'est pas moins évolutif les autres solutions (à l'exclusion de Boost / TR1 Tuple). Et ... c'est le plus rapide :) (comme code d'écriture). À propos du laid ... c'est juste faire le travail. Juste mon avis                                                
                                                
                                                                                            
                                                    CProgrammather, c'est bien mieux que la solution choisie pour certaines applications: par exemple une programmation concurrentielle.

Articles qui pourrait vous intéresser : Catalina C ++: L'utilisation d'en-têtes <cmath> génère une erreur: aucun membre nommé 'signbit' dans l'espace de noms global installation du compilateur c ++ 11 (+) sans autorisation d'administrateur Application de console C ++ VS2019 - Le débogueur n'acceptera pas les arguments de commande Meilleur moyen en C ++ de garder une grosse structure atomique?