Cartes Java

    • Préface
      • Introduction
          • 1.1. Outil de validation
            • 1.2. Langages et notations utilisées
              • 1.3. Visualisations avec des cartes à jouer
                • 2.1. Objets
                  • 2.2. Tableaux d'objets
                    • 2.3. Graphes d'objets
                      • 3.1. Performance Vs efficacité
                        • 3.2. Efficacité en temps
                          • 3.3. Efficacité en espace
                            • 4.1. Liste naïve
                              • 4.2. Liste par tableau
                                • 4.3. Liste chaînée simple
                                  • 4.4. Liste chaînée double
                                    • 5.1. Arbre générique
                                    • 5.2. Arbre binaire
                                    • 6.1. Mappage naïf
                                      • 6.2. Mappage par hachage
                                        • 6.3. Mappage avec arbre
                                        • Conclusion
                                        • Bibliographie
                                            • Annexe 1: la notation grand O
                                              • Annexe 2: accéder aux exemples
                                                • Annexe 3: programmer un nouvel exemple
                                                  • Annexe 4: suggérer une modification à ce manuel
                                                      • Procédures déplacer/décaler
                                                        • Modéliser la suite de Fibonacci
                                                          • Liste par tableau
                                                            • Arbre binaire
                                                              • Bilan juin 2022
                                                              • Bilan octobre 2022
                                                            Visualisations avec des cartes à jouer
                                                            • 1.3 Visualisations avec des cartes à jouer
                                                              • 1.3.1 Liste ou tableau à une dimension
                                                              • 1.3.2 Arbre

                                                            Section 1.3: visualisations avec des cartes à jouer #

                                                            Dans notre approche, il n’y a pas de façon unique de visualiser les données d’une procédure informatique avec des cartes à jouer. Pour chaque procédure, il faut donc spécifier la visualisation à utiliser (l’Annexe 3 explique comment programmer une nouvelle visualisation). Nous donnons ici deux exemples de telles visualisations.

                                                            1.3.1 Liste ou tableau à une dimension #

                                                            Lorsque les données sont sous la forme d’une liste (ou d’un tableau à une dimension), on peut facilement visualiser cette liste par une séquence de cartes disposées, p. ex. de gauche à droite. On peut aussi utiliser des marqueurs (petits objets) pour représenter des positions (indices) dans cette liste.

                                                            P. ex. le code suivant :

                                                            Carte[] cartes;
                                                            
                                                            int aDeplacer;
                                                            int i;
                                                            
                                                            Carte memoireA;
                                                            Carte memoireB;
                                                            

                                                            est aisément visualiser par les cartes et les marqueurs suivants :

                                                            À noter qu’une carte blanche représente une case vide (valeur null).

                                                            1.3.2 Arbre #

                                                            Dans le cas où les données sont organisées sous forme d’arbre, on peut visualiser les données en disposant aussi les cartes en forme d’arbre.

                                                            P. ex. l’arbre suivant (racine en haut, comme le veut la convention) :

                                                            Serait visualisé par les cartes suivantes :

                                                            À noter que la visualisation dépend d’une compréhension préalable de la notion d’arbre (de la forme d’un arbre). Cette compréhension préalable risque d’être moins acquise chez les étudiant·e·s que celle de séquence utilisée ci-haut. Néanmoins, utiliser des cartes peut s’avérer plus intuitif pour les novices que le format textuel. P. ex. voici le même arbre en JSON :

                                                            {
                                                                "_C": "Noeud",
                                                                "valeur": 4,
                                                                "enfantGauche": {
                                                                    "_C": "Noeud",
                                                                    "valeur": 2,
                                                                    "enfantGauche": {
                                                                        "_C": "Noeud",
                                                                        "valeur": 1,
                                                                        "enfantGauche": null,
                                                                        "enfantDroit": null
                                                                    },
                                                                    "enfantDroit": {
                                                                        "_C": "Noeud",
                                                                        "valeur": 3,
                                                                        "enfantGauche": null,
                                                                        "enfantDroit": null
                                                                    }
                                                                },
                                                                "enfantDroit": {
                                                                    "_C": "Noeud",
                                                                    "valeur": 6,
                                                                    "enfantGauche": {
                                                                        "_C": "Noeud",
                                                                        "valeur": 5,
                                                                        "enfantGauche": null,
                                                                        "enfantDroit": null
                                                                    },
                                                                    "enfantDroit": {
                                                                        "_C": "Noeud",
                                                                        "valeur": 7,
                                                                        "enfantGauche": null,
                                                                        "enfantDroit": null
                                                                    }
                                                                }
                                                            }
                                                            


                                                            ↪ Chapitre 2:  modélisation des données et limitations de...
                                                            FabriqueREL
                                                            Creative Commons License
                                                            Modifier cette page Edit
                                                            Collège Montmorency
                                                            • 1.3 Visualisations avec des cartes à jouer
                                                              • 1.3.1 Liste ou tableau à une dimension
                                                              • 1.3.2 Arbre