Structures de données… alors comment les comprendre?

Je suis donc étudiant en informatique et à peu près une semaine environ … Je vais reprendre un cours sur les structures de données en utilisant C ++ pour appliquer la théorie. Oui, j’ai dit “reprendre”. J’ai suivi le cours l’automne dernier et j’ai l’impression qu’il y a plus à apprendre. En tant qu’étudiant, je sens que je DOIS connaître les bases car il sera beaucoup plus facile de comprendre les nouveaux concepts dans les classes futures en connaissant déjà les concepts de base… sans avoir à réapprendre à chaque fois.

La première fois, je n’avais aucune expérience en C ++ et le cours prévoyait que nous codions à la fin de la première semaine. J’ai eu du mal à franchir plusieurs des premières missions de programmation (MP). Inutile de dire que je m’y suis habitué et que j’ai eu peu de problèmes avec la syntaxe le rest du semestre. Mais ensuite, les structures de données les plus difficiles sont apparues et la théorie (Big O) est devenue difficile.

Dans l’ensemble, c’était une expérience formidable, mais je pense que mon problème était que je ne développais pas de bonnes habitudes d’étude. J’ai fait les députés et je suis venu pour donner des conférences, mais il semble que mon cœur n’était pas là avec moi. Je veux changer cela la deuxième fois car en regardant la classe, j’ai passé un bon moment et j’ai apprécié le matériel. Mais je me suis retrouvé à passer trop de temps à penser / mettre en place la ou les structures de données lorsque je devais passer du temps à réfléchir à la manière d’utiliser efficacement la structure de données.

La théorie de l’apprentissage est difficile (surtout parce que ce n’est pas si excitant), alors comment dois-je m’appliquer pour vraiment comprendre la classe couverte par les structures de données? J’ai toujours été un apprenant visuel, un apprenant interactif … Je ne veux pas passer mon temps à faire mes députés. Je veux plutôt passer mon temps de telle manière que j’apprenne vraiment les concepts et que je les applique directement.

Je suis à la recherche de suggestions… peut-être des conseils sur les habitudes d’étude qui vous ont été utiles dans le passé en apprenant de tels concepts… ou des suggestions sur de bonnes techniques de prise de notes… tout ce que vous aimeriez partager 🙂 … et surtout, comment se préparer avant le début du semestre.

N’hésitez pas à nous faire part de vos commentaires même si une réponse a été sélectionnée. Je cherche ton conseil … c’est pour ça que j’ai posté 🙂 Merci!


REMARQUE : Les structures de données et les sujets abordés dans le cours: listes, stacks, files d’attente, arbres (différents types), tables de hachage, graphiques, techniques de recherche / sorting / transposition.


MISE À JOUR : Voici une liste de liens et de références compilés à partir des réponses obtenues jusqu’à présent.

  • Algorithmes en C ++ par Robert Sedgewick
  • Introduction aux algorithmes par Cormen
  • Dictionnaire d’algorithmes et de structures de données du NIST
  • Algorithmes de sorting
  • Traversées d’arbres
  • Traversées de graphiques
  • http://www.codeproject.com/KB/cpp/linked_list.aspx
  • http://www.codeproject.com/KB/architecture/treedata_class.aspx

MISE À JOUR 2 : Voici une liste d’autres sources que j’ai trouvées:

  • http://people.ksp.sk/~kuko/bak/big/
  • http://webdiis.unizar.es/asignaturas/EDA/AVLTree/avltree.html
  • http://www.dgp.toronto.edu/people/JamesStewart/270/9798s/Laffra/DijkstraApplet.html
  • http://www.cs.duke.edu/csed/jawaa2/examples/BFS.html

Vous avez déjà reçu des liens et des idées intéressants. J’espère pouvoir fournir un sharepoint vue un peu différent:

J’ai appris à visualiser et à “aimer” les structures de données en apprenant que la mémoire informatique est une liste très longue. Les structures ont alors une disposition différente dans la mémoire. En visualisant les structures dans la mémoire, il est devenu évident pour moi (et intéressant) leur fonctionnement. Connaître la disposition des données en mémoire est extrêmement important pour un programmeur, car les machines en croissance constante sont souvent bloquées par l’access à la mémoire. Une bonne disposition de la mémoire facilite la tâche du processeur pour récupérer les données de la mémoire afin que le processeur n’ait pas à attendre que les données arrivent.

Les structures de données sont la disposition des données dans une mémoire. Considérez la mémoire comme une longue liste, tout comme une liste de courses, mais sans les entrées.

0... 1... 2... 3... 4... 5... 6... 

Lorsque vous mettez des structures en mémoire, elles remplissent essentiellement ces emplacements en mémoire.

Une liste est très simple, elle remplit simplement la liste mémoire du haut en bas:

 0 Element 0 1 Element 1 2 Element 2 3 Element 3 

Bien que parfois vous vouliez changer l’élément 2 en quelque chose d’autre, peut-être zéro. C’est comme ça que les listes fonctionnent. Vous pouvez accéder aux données de la structure en connaissant leur index (dans ce cas, 0 .. 3).

Les stacks sont différentes. Vous ne pouvez accéder au “sumt” d’une stack qu’en “poussant” un élément vers le haut ou en “faisant apparaître” un élément depuis le haut. Pousser signifie append un autre élément et l’ancien sumt devient invisible. Poping signifie enlever l’élément supérieur et celui en dessous devient visible.

 0 [ Hidden data ] . [ Hidden data ] . [ Hidden data ] . [ Hidden data ] n [ Hidden data ] n+1 Element 4 

Les listes liées sont différentes. Une liste chaînée contient un pointeur (index dans la liste de mémoire) vers les données et un pointeur vers l’élément suivant:

 0 Data: Memory index 0x00000100 1 Next: Memory index 6 2 3 4 5 6 Data: Memory index 104 7 Next: Memory index 8 ... 100 Data pointed to from first member 101 102 103 104 Data pointed to from second member 

La queue est comme une stack plus puissante, vous avez access au bas et au haut. Vous ne pouvez que pousser des objects vers le haut et vous ne pouvez faire apparaître que des objects par le bas.

 0 (bottom) Element (ready to be popped) 1 [ Hidden data ] 2 [ Hidden data ] 3 [ Hidden data ] . . . n (top) (empty, ready to be pushed / be given data) 

En visualisant la disposition de chaque structure de données, elles sont devenues beaucoup plus évidentes pour moi en ce qui concerne la manière dont elles nécessitent de la mémoire et leur fonctionnement réel ( également dans la mémoire ). J’espère que mes exemples vous ont donné de brèves connaissances de base pour vos futures études. Comme dernier exemple sur les structures de données, je vais vous donner un arbre binary déséquilibré qui a eu l’ordre suivant d’insertion des éléments: 3, 2, 1, 10, 9, 8, 6, 5, 4, 7

L’arbre commence à l’adresse mémoire 100, car l’adresse mémoire 0 n’est pas valide et je l’utiliserai comme un “pointeur”.

 100 Value: "3" 101 Left ptr: 103 102 Right ptr: 109 103 Value: "2" 104 Left ptr: 106 105 Right ptr: 0 106 Value: "1" 107 Left ptr: 0 108 Right ptr: 0 109 Value: "10" 110 Left ptr: 112 111 Right ptr: 0 112 Value: "9" 113 Left ptr: 115 114 Right ptr: 0 115 Value: "8" 116 Left ptr: 118 117 Right ptr: 0 118 Value: "6" 119 Left ptr: 121 120 Right ptr: 127 121 Value: "5" 122 Left ptr: 124 123 Right ptr: 0 124 Value: "4" 125 Left ptr: 0 126 Right ptr: 0 127 Value: "7" 128 Left ptr: 0 129 Right ptr: 0 

J’espère que cela pourra aider!

Voici ce qui m’a le plus aidé … Puisque vous êtes une personne visuelle, Google a mis au sharepoints algorithmes de sorting, des parcours d’arbres, du hachage, etc. pour avoir une idée générale de ce qui se passe. Après cela, essayez de créer un programme simple en utilisant différentes structures et en expérimentant différentes permutations – peut-être pour un exemple, vous pouvez créer une liste chaînée pour commencer, puis en faire une liste chaînée circulaire, puis en faire une liste doublement liée, puis en faire une liste chaînée doublement circulaire, et ainsi de suite …

Il vous suffit d’expérimenter les structures et, ce faisant, vous commencez à voir quelles structures de données conviennent aux applications que vous développerez.

Voici quelques références intéressantes pour vous. Algorithmes de sorting: http://www.sorting-algorithms.com/ Traversées d’arbres: http://nova.umuc.edu/~jarc/idsv/lesson1.html Traversées de graphiques: http: //www.cosc.canterbury.ac.nz/mukundan/dsal/GraphAppl.html


Pour ce qui est de l’efficacité (parsing Big O), il vous arrivera plus ou moins naturellement une fois que vous aurez compris ce qui se passe au niveau algorithmique de chaque opération de la structure de données.

Une chose que mon université souligne est le développement de notre propre implémentation de structures de données (qui est un apprentissage ascendant) sans plonger dans les modèles C ++ préétablis (apprentissage descendant). En partant de rien, vous comprenez vraiment la surcharge liée à l’insertion, à la suppression, à la recherche (traversée) et à l’access aux données d’une certaine structure, ce qui vous aidera à concevoir un système à l’avenir.

Pratique, pratique, pratique.

Le premier conseil que j’ai pour vous est de devenir aussi compétent que possible chez C ++.

Les structures de données et la programmation sont deux sujets très différents. Si vous rencontrez des difficultés avec la programmation, il est peu probable que vous puissiez comprendre les structures de données.

Comment devenez-vous compétent en C ++? Pratique, pratique, pratique. Tout programmer Apprenez tout ce que vous pouvez à ce sujet. Écrivez des dizaines de petits programmes. Tout ce que vous pouvez faire pour vous familiariser avec C ++.

Si vous maîsortingsez le C ++, je vous assure que les structures de données deviendront plus faciles. (Notez que je n’ai pas dit facile, j’ai dit plus facile :))

La clé de l’apprentissage des structures de données est de commencer avec quelque chose de petit, puis d’en tirer parti. Commençons par une structure C simple:

 struct Person { char name[100]; int age; }; 

Cette structure de données représente une personne. Vous devez vous assurer que vous comprenez des concepts de structure simples comme ceux-ci et que vous pouvez ensuite passer à des choses plus grandes.

Lorsque vous commencez à parler de structures de données telles que les stacks et les files d’attente, par exemple, essayez d’abord de comprendre conceptuellement la structure des données. Par exemple, avec une stack, nous utilisons le principe LIFO, c’est-à-dire Last In First Out. Avec une queue, nous utilisons le principe FIFO (premier entré, premier sorti).

Et puis, il y a celle qui déclenche beaucoup de personnes, la liste chaînée. Vous devez bien comprendre les pointeurs de cette liste, alors avant d’essayer de vous attaquer aux listes liées, commencez par quelque chose de simple:

 int* x; int y = 10; x = &y; 

Vous devriez pouvoir regarder ce code et savoir immédiatement ce qu’il fait. Si vous ne le pouvez pas, vous n’êtes pas prêt à passer à des structures de données plus avancées, telles que les listes liées.

Le point principal que j’essaie de faire valoir est que vous devez réduire les bases, puis les développer. Il est également important de suivre le cours avec beaucoup de diligence, demandez à votre professeur ou à votre tuteur si vous rencontrez des problèmes et assurez-vous que vous êtes sur la bonne voie chaque semaine et que vous ne prenez pas de retard.

Les cours d’informatique sont un peu comme les cours de mathématiques, chaque semaine se base généralement sur tout ce que vous avez appris des N semaines précédentes. Donc, si vous ne comprenez pas un concept clé, comme les pointeurs par exemple, vous allez avoir des difficultés majeures le rest du semestre.

J’aime la réponse de dcp.

La meilleure façon d’englober les structures de données est d’écrire des mini-exemples. Même si vous les copiez depuis votre livre, si vous pouvez les faire fonctionner et les comstackr, et que vous les avez tapés avec vos propres doigts, vous en apprendrez beaucoup.

En lisant votre livre et après chaque cours, écrivez les programmes les plus courts possibles (création, utilisation, etc.) de la structure de données que vous venez d’apprendre.

Ensuite, lorsque vous devez effectuer vos tâches réelles, vous en apprendrez encore plus en essayant de prendre vos mini-exemples et en les branchant dans la résolution des problèmes d’affectation.

Je pense que l’écriture du code de travail le plus court / le plus petit possible pour des structures de données individuelles est très utile. Aussi, n’ayez pas peur de copier du code (pour votre propre édification, pas pour vos assertions retournées) …. Si vous copiez en tapant et non pas copiez le collage, vous finissez par apprendre beaucoup, car cela vous oblige regarder chaque caractère dans le code.


Si des structures de données entières semblent “trop” pour en venir à bout, commencez par écrire des mini-exemples des composants des structures de données. Stockez donc un titre de livre avec un pointeur. Ensuite, stockez de nombreux titres de livres avec des pointeurs vers des pointeurs. Lire un titre de livre avec une notation entre crochets et une arithmétique de pointeur. Utilisez la récursion dans des fonctions simples où il est clair ce qui se passe ….. Par exemple, la récursivité pour montrer la factorielle d’un nombre est plus simple que de récurer pour afficher un arbre binary (à mon avis) … ..

Vous verrez quels sont vos problèmes, et essayez de les isoler de la manière la plus petite et la plus spécifique possible, puis écrivez un programme aussi court que possible qui traite de ce problème ….. et ensuite accumuler.

Vos cours portent sur des structures de données entières … les banques de théorie du nuage Cummulus géant … donc, essentiellement, elles sont de haut en bas. Isoler les petits problèmes de syntaxe et d’utilisation dans les mini problèmes est un problème de bas en haut. Donc, votre professeur vous aide à attaquer par le haut, vous attaquez par le bas en vous entraînant, et bientôt il n’y a plus rien au milieu!

La seule manière d’apprendre de manière significative les structures de données et les algorithmes consiste à les voir appliquer à des problèmes réels et à les utiliser pour résoudre des problèmes réels. Les coder dans des applications de travail – même si elles sont artificielles – renforcera les connaissances théoriques de sorte que vous aurez de meilleures chances de conserver les idées et de les intégrer dans votre approche personnelle de résolution de problèmes.

Je recommanderais d’obtenir un bon livre sur les algorithmes (“Introduction to Algorithms” de Cormen et al. Serait ma recommandation). A travers le livre, vous développerez et utiliserez des structures de données différentes et vous réaliserez probablement à quoi sert chaque structure. Les structures de données ne sont utiles que pour atteindre un objective différent: résoudre un problème particulier.

Selon le temps dont vous disposez ou que vous souhaitez dépenser, vous pouvez essayer d’obtenir des problèmes lors de différents concours de programmation, tels que l’ACM ICM. La plupart des problèmes nécessiteront que vous exerciez ces connaissances. Notez que les algorithmes et les structures de données sont indépendants de la langue, donc si vous avez une bonne connaissance de toute autre langue, utilisez-la.

À mon avis, ces choses sont mieux apsockets sur le tas, ou par l’expérience que dans un cours théorique. La plupart du temps, alors que j’étais à l’école, travailler dur pour restr en tête était la partie importante, qui, à mon avis, est similaire à l’expérience que vous avez vécue. Bien qu’il soit louable que vous souhaitiez le comprendre à fond, tant que vous savez où trouver de bons documents de référence lorsque vous en avez besoin, le cours a atteint son objective.

La plupart des cours s’appuieront sur les connaissances que vous avez acquises dans les cours précédents. Vous rencontrerez ces détails à nouveau dans vos études et vos professeurs devraient être en mesure de vous aider à appliquer ce que vous avez appris dans le passé à votre travail en cours. En tant qu’apprenant interactif, les heures de bureau, les stages et les opportunités de mentor semblent être les meilleurs moyens d’obtenir les informations que vous souhaitez.

Bonne chance!

Une chose dont vous devez toujours vous souvenir, c’est que les structures de données n’existent pas. Ils ont été inventés pour répondre à un besoin, ce qui signifie qu’ils sont bons pour certaines raisons, mais pas pour d’autres.
Découvrez quelles sont ces raisons, quelle est la structure des données, essayez de comprendre le Big O pour les opérations avant que vous ne leur disiez.
Toujours comparer les structures de données. Même avec le plus simple d’entre eux – Un tableau. Prenez cela comme sharepoint départ et comparez chaque structure de données que vous trouvez à un tableau. Parfois, vous trouverez de petites astuces qui vous aideront à éviter d’utiliser la structure Big Data.
Pour moi, ce qui m’a aidé à comprendre beaucoup de structures de données et d’algorithmes était l’applet ici, et j’espère que cela vous aidera aussi: Applet

Si vous pouvez visualiser l’implémentation de structures de données dans la vie réelle ou pour résoudre des problèmes réels, vous trouverez peut-être plus facile à comprendre.

Voici quelques-uns

  1. FIFO Linked List – C’est le lecteur chez McDonalds
  2. LIFO Linked List – Une stack d’assiettes
    • Recherche et sorting – Un Rolodex (si vous êtes vieux, vous avez déjà vu une de ces choses)

Voici un article intéressant pour vous aider à démarrer: http://www.codeproject.com/KB/cpp/linked_list.aspx. Commencez avec une simple liste chaînée. C’est très facile et vous le comprendrez beaucoup plus facilement que les autres structures de données. La stack et la queue sont peut-être conceptuellement encore plus faciles, mais elles sont basées sur la simple liste chaînée. Vous pouvez ensuite passer à des listes et des arborescences liées. Au plaisir de voir vos questions de codage, bonne chance! 🙂

Si vous êtes un apprenant visuel, demandez à votre instructeur des diagrammes supplémentaires. Vous pourriez demander à d’autres étudiants si vous pouvez étudier avec eux. Peut-être l’un d’entre eux peut-il vous expliquer plus facilement les choses?

Le dictionnaire des algorithmes et des structures de données du NIST est une bonne ressource. Vous n’allez pas vous asseoir et mémoriser toutes ces informations, et vous ne devriez pas les utiliser pour éviter de coder vos propres structures, cela annulerait complètement la valeur de la classe, mais ce site sert de référence parce qu’il relie les structures de données avec les algorithmes qui les utilisent et montre également certaines variantes, ce qui permet de mieux comprendre comment modifier les structures pour d’autres utilisations.

J’espère que cela pourra aider. Bonne chance.


Je peux me souvenir de mon premier cours sur les structures de données. Je me souviens avoir été un peu dépassé au début.

J’étais plus un apprenant visuel. Pour mieux saisir le matériel, il a vraiment aidé à voir des images. J’avais l’habitude de définir les étapes d’insertion, de suppression et d’itération à travers des structures de données telles qu’une liste chaînée ou une queue. Il a fallu beaucoup de papier avant d’avoir fini, mais ça en valait la peine.

Une fois que j’ai dessiné le processus d’insertion et ce qui ne l’est pas, la transition vers la programmation réelle de la structure de données était beaucoup plus facile.

Être capable de visualiser ce qui se passait en mémoire a vraiment aidé. Et, comme d’autres l’ont déjà mentionné: pratique, pratique, pratique!

Qu’il y a une grande partie du succès.

Bonne chance!

Je ne suis pas sûr que ce soit une aide, mais cela peut être encourageant.

J’étais dans le même bateau quand j’ai pris Data Structures il y a 4 ans. J’ai parcouru la classe avec suffisamment de connaissances pour me débrouiller et obtenir le B, au moins, dans la classe même si je ne comprenais pas grand-chose.

Je ne comprenais pas les modèles, les listes liées, les pointeurs «this», et je ne comprenais pas vraiment bien les pointeurs en général, ce qui entravait grandement mes capacités. J’ai miraculeusement fait ce qu’il fallait sur les devoirs et les tests (bien que les résultats des tests étaient encore bas pour tout le monde et que mon professeur les ait courbés) et fini avec un B.

Après cela, j’ai suivi d’autres cours pendant quelques années. J’ai trouvé que dans ces classes, différents concepts étaient enseignés séparément, ce qui m’a aidé à mieux les comprendre. Les algorithmes en ont appris plus sur le sorting et Big O, Assembly a appris plus sur ce qui se passait “sous le capot” de l’ordinateur, ce qui m’a aidé à comprendre les pointeurs, etc.

J’ai réalisé du deuxième au dernier semestre de ma cinquième année que je connaissais à peu près tous les concepts de Data Structures et que je n’avais même pas fait d’efforts supplémentaires pour les apprendre, du moins pas pour essayer de comprendre Structures de données, si cela a du sens.

Sans aucun effort réel, je me suis retrouvé à écrire une queue et une stack basée sur des listes de liens pour quelques devoirs dans les systèmes d’exploitation et je les ai compris. Il m’a fait sauter. Je suis certain que ce sera la même chose pour vous. Donnez-lui du temps et concentrez-vous sur les autres classes et tout ira bien. Cela a semblé prendre pour toujours pour que tout clique pour moi, mais il l’a fait.

J’espère que cela pourra aider.

Honnêtement, je suis un programmeur C ++ autodidacte à l’origine (avec ma principale référence étant le code du domaine public du moteur de jeu Source de Half-Life 2), et j’ai appris beaucoup de choses à travers des structures de données. commentaires et code.

Peut-être que je suis juste un prodige, parce que cela m’a toujours semblé relativement facile, mais j’ai appris BEAUCOUP de temps à lire, à réfléchir et à parsingr les utilisations particulières de chaque structure, et pourquoi chaque structure existe en tant que quelque chose de séparé des autres structures de données en premier lieu.

Ayant écrit des projets de code sérieux (c.-à-d. Connect Four et un jeu de tir spatial à défilement latéral, ainsi que des traceurs isomésortingques 3D et des programmes de dessin 2D) sur la calculasortingce TI-83 Plus très limitée au lycée (ps pas d’ assemblage), j’ai réalisé quels types d’opérations étaient plus efficaces, et j’ai réalisé à quel point le système de listes intégré (un vecteur de base) était limité pour le stockage des données dans certaines situations. J’ai également compris comment Big-O fonctionnait lorsque j’ai essayé de synchroniser le temps d’exécution d’un programme avec des listes d’entrées de taille différente.

Entraînez-vous, pensez aux choses pendant que vous les faites et essayez de comprendre comment et pourquoi ils fonctionnent, et n’ayez jamais peur de vous mettre à l’essai avec les tests. Après tout, qu’est-ce que la science sans expérimentation?

Lorsque j’ai enseigné la programmation, j’ai toujours référé les livres démystifiés à mes étudiants.

Je vous suggère de lire:
– Structures de données démystifiées
– OOP démystifié

Ces deux livres réussissent à décomposer les structures de données et le principe de la POO en termes plus faciles à lire, avec des exemples faciles à suivre. C’est un bon aperçu, mais il ne va pas dans les structures de données fournies par la STL.

Donald Knuth “L’art de la programmation informatique”, vol 1 .

En pratique, je trouve que les structures de données nécessitent une solide compréhension des pointeurs et de la mémoire.

Par exemple, vous devriez être en mesure de comprendre pourquoi la liste liée ci-dessous ne fonctionne pas en moins d’une minute.

Mais pour comprendre pourquoi cela ne fonctionne pas, vous devez comprendre comment la mémoire est disposée en C et C ++ et comprendre intuitivement le concept de pointeur.

Certaines personnes aiment les photos et les dessinent. D’autres personnes aiment regarder le MIT OpenCourseware – je recommande d’essayer au moins.

 class node { int data; node* next; node* addnode() { node newnode; this->next = &newnode; return &newnode; } }; 

Ceci est une approximation d’une implémentation (bugée) d’une liste chaînée que j’ai écrite il y a environ 10 ans lorsque j’apprenais des structures de données.

Enfin, la pratique et la théorie sont le yin et le yang d’un programmeur / développeur / informaticien de qualité. Vous ne pouvez pas être vraiment compétent sans les deux.

Si vous avez des problèmes avec la notation O, alors “Introduction aux algorithmes” de Cormen et.al. introduit ces concepts théoriques dans un style facile à comprendre. Eh bien, ce livre est essentiellement la bible pour les structures de données de base. Les épreuves d’exécution / limites d’espace sont toujours présentées de manière très instructive.

Comme toujours, si vous étudiez un tel livre, ne vous contentez pas de le lire, mais essayez de travailler sur la plupart des exercices. Habituellement, cela est très efficace pour apprendre les choses.

Une autre technique générale: essayez de vous joindre à un groupe d’étude local composé de 2 ou 3 autres étudiants – en général, en discutant avec les autres (face à face) et en essayant d’expliquer la matière étudiée à vos pairs choses que vous devez couvrir plus.

Pour maîsortingser le C ++ pour les exercices, «Le langage de programmation C ++» de Stroustrup donne une bonne introduction et une référence aux différents concepts de langage. C ++ étant un langage à paradigmes multiples, les débutants ont souvent du mal à comprendre quels concepts utiliser en pratique pour résoudre certains problèmes. Aider avec ce «Effective C ++» de Scott Myers est un bon début.

Si votre cours fait un usage intensif du STL, il existe également un «STL efficace». Le style d’écriture de Scott Myers est généralement considéré comme très approprié pour les débutants.

Pour moi, le meilleur livre que j’ai trouvé (jusqu’à présent) pour comprendre les structures de données est The Algorithm Design Manual de Steven Skiena.
Mis à part la première partie couvrant l’parsing des algorithmes, les algorithmes et les structures de données, la deuxième partie est absolument inestimable pour trouver (ou du moins réduire) la structure de données / l’algorithme approprié pour résoudre un problème.