0
votes

Structure de données pour le comportement FIFO et la recherche rapide par la valeur

Je suis donc à la recherche d'une structure de données qui a besoin d'un comportement FIFO, mais doit également avoir une recherche rapide de la valeur.

Dans mon code actuel, j'ai une duplication de données. J'utilise un STD :: Unorded_sed_sed_sed_sed_sed_sed_sed_sed_sed & STD :: File d'attente pour obtenir le comportement que je veux, mais il y a probablement un meilleur moyen d'y parvenir que je ne pense pas à ce moment-là. J'ai une fonction qui ajoute ma nouvelle entrée à la fois à l'ensemble et à la file d'attente lorsqu'une nouvelle entrée apparaît. Pour rechercher si une entrée existe dans la file d'attente, j'utilise Rechercher () dans l'ensemble. LASLTY, j'ai une minuterie qui est déclenchée après une insertion à la file d'attente. Après une minute, je reçois l'entrée à l'avant de la file d'attente avec la file d'attente.front (), alors j'utilise cette valeur pour effacer à partir de l'ensemble et enfin, je fais une pop sur la file d'attente.

Tout cela fonctionne comme prévu et me donne à la fois le comportement de la FIFO et la complexité de temps constante de la recherche, mais j'ai une duplication de données et je me demandais s'il y a une structure de données (peut-être quelque chose de boost?) Ce que je fais vouloir sans la duplication.


6 commentaires

boost.org/doc/libs/1_73_0/libs/ MULTI_INDEX / DOC / INDEX.HTML


Pour simplement éviter une double duplication potentielle, il suffirait d'utiliser un itérateur dans l'ensemble être utile?


Aussi pour améliorer la question que vous pouvez ajouter du code


Dans votre schéma, STD :: Shared_PTR NON Élimine la duplication de données ou vos éléments de données sont très petits, par exemple entiers?


@Darune Une partie du code que je ne suis pas autorisé à montrer en ligne, conformément aux règles de la société.


@Muhamadgafar puis vous réécrivez ces pièces et montrez ce que vous pouvez, d'autres choses à améliorer pourraient aller un pas en arrière donner plus d'arrière-plan à la question (par exemple, im rédigez cette "cacherie de serveur Web" ou autre)


3 Réponses :


2
votes

Structure de données pour le comportement FIFO et la recherche rapide par la valeur

Une solution consiste à utiliser deux conteneurs: stockez les éléments dans un ensemble non ordonné pour une recherche rapide et sur l'insertion, stockez Itérateur à l'élément dans une file d'attente. Lorsque vous allez faire la queue, effacez l'élément correspondant de l'ensemble.

Une approche plus structurée consiste à utiliser un conteneur multi-index. La bibliothèque standard ne fournit pas de telles, mais boost < / a> fait. Plus spécifiquement, vous pouvez utiliser une combinaison d'indices hachés et de séquence.


0 commentaires

0
votes

Cette réponse concerne principalement les cas d'angle du problème tel que présenté

Si vous posez un problème est pratique, et vous pouvez stocker les éléments avec un std :: vecteur < / Code> - Et si vous avez moins que dans le ballpark d'environ 10-100 éléments dans la file d'attente, vous pouvez simplement utiliser: xxx

c'est une file d'attente Vecteur comme le conteneur sous-jacent. Lorsque vous avez ce petit nombre d'éléments (seulement 10-100), l'utilisation de méthodes de recherche avancées n'en vaut pas la peine.

Vous n'avez alors besoin que de vérifier les doublons lorsque vous avez la file d'attente de tous les Insertion. à nouveau, cela pourrait ou non être utile en fonction de votre cas spécifique. Je peux imaginer des cas où cette méthode est supérieure. Par exemple. Un serveur Web servant des pages qui obtiennent beaucoup de hits à une ou quelques pages. Ensuite, il peut être plus rapide d'ajouter seulement 100 000 éléments au vecteur, puis de partir et de supprimer les duplicats tout en une fois lors de la saut.


0 commentaires

0
votes

Que diriez-vous de définir votre propre structure de données pouvant agir en tant que BST (pour les recherches) et en tant que Min de tas que vous pouvez utiliser pour imposer FIFO?

class node {
    public:
    static int autoIncrement = 0;
    
    int order; // this will be auto-incremented to impose FIFO
    int data;
    
    node* left_Bst;
    node* right_Bst;

    node* left_Heap;
    node* right_Heap; 

    node() {
        order = autoIncrement;
        autoIncrement++;
    }
}


0 commentaires