Partage de technologie

2025~Questions du test « Structure des données »~Examen d'entrée de troisième cycle

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Page d'accueil de l'auteur: Zhi Guyun sort de Xiu
Insérer la description de l'image ici

  1. Questions à choix multiple: Examiner les concepts de base et les opérations de base
  2. Remplir les espaces vides: Renforcer la compréhension des concepts et des détails de base
  3. questions à réponse courte: Tester la maîtrise des connaissances théoriques
  4. Questions de programmation: Tester la capacité de programmation réelle et l'application de la structure de données
  5. Insérer la description de l'image ici

Volume de simulation de structure de données

1. Questions à choix multiples (2 points chacune, 20 points au total)

  1. La complexité temporelle de l'insertion d'un élément dans un tableau est de ().
    A.O(1)
    B. O(n)
    C.O(log n)
    D.O(n^2)

  2. Dans le tri par tas, la complexité temporelle de la construction d'un tas maximum est ().
    A. Sur(n)
    B. O(n log n)
    C.O(log n)
    D.O(n^2)

  3. Un arbre rouge-noir est un type de ().
    A. Arbre binaire complet
    B. Arbre binaire équilibré
    C. Min-tas
    D. Tas maximum

  4. Laquelle des affirmations suivantes concernant les tables de hachage est incorrecte ().
    A. La complexité du temps de recherche de la table de hachage est O(1)
    B. La complexité du temps d'insertion de la table de hachage est O(1)
    C. Les tables de hachage peuvent résoudre les conflits
    D. La complexité du temps de recherche de la table de hachage doit être O(1)

  5. Dans le parcours graphique, la complexité temporelle de la recherche en profondeur d'abord (DFS) et de la recherche en largeur d'abord (BFS) est respectivement ().
    A. O(V + E) et O(V)
    B. O (V ^ 2) et O (V)
    C. O(V + E) et O(V + E)
    D.O(V) et O(V^2)

  6. La complexité temporelle de l’inversion d’une liste chaînée unidirectionnelle est ().
    A.O(1)
    B. O(n)
    C.O(log n)
    D.O(n^2)

  7. Dans un arbre de recherche binaire, la complexité temporelle la plus défavorable de la suppression d'un nœud est ().
    A.O(1)
    B. O(n)
    C.O(log n)
    D. O(n log n)

  8. Lequel des algorithmes de tri suivants a une complexité temporelle moyenne de O(n log n)().
    A. Tri à bulles
    B. Tri rapide
    C. Tri par insertion
    D. Tri par sélection

  9. Dans un arbre binaire, le degré d'un nœud est ().
    A. Le nombre de nœuds enfants de ce nœud
    B. La profondeur du nœud
    C. La hauteur du nœud
    D. Le niveau du nœud

  10. La principale différence entre B-tree et B+-tree est ().
    A. Tous les nœuds de l’arbre B stockent des données, tandis que seuls les nœuds feuilles de l’arbre B+ stockent des données.
    B. L'arbre B est plus équilibré que l'arbre B+
    C. Les opérations d'insertion et de suppression de B-tree sont plus simples
    D. L'efficacité de la recherche de l'arbre B+ est inférieure

2. Questions à remplir (3 points chacune, 15 points au total)

  1. La hauteur d'un arbre binaire complet contenant n nœuds est ______.
  2. La complexité temporelle moyenne du tri rapide est de ______.
  3. Dans une liste chaînée, la complexité temporelle de la recherche du kième élément est de ______.
  4. La complexité spatiale de la représentation matricielle d’adjacence d’un graphe est ______.
  5. Dans un arbre de Huffman, la longueur pondérée du chemin est calculée comme suit : ______.

3. Questions à réponse courte (10 points chacune, 30 points au total)

  1. Veuillez décrire brièvement les propriétés des arbres rouge-noir et expliquer comment les arbres rouge-noir maintiennent l'équilibre.
  2. Expliquez la différence entre les tableaux dynamiques et les listes chaînées, et discutez de leurs avantages, inconvénients et scénarios d'application.
  3. Décrire les principes des tables de hachage et expliquer comment gérer les collisions.

4. Questions de programmation (15 points chacune, 35 points au total)

  1. Veuillez implémenter une fonction pour déterminer si une liste chaînée est une liste chaînée palindrome.

    def is_palindrome(head):
        # 请在这里编写代码
    
    • 1
    • 2
  2. Veuillez écrire du code pour implémenter l'opération d'insertion dans l'arborescence de recherche binaire.

    class TreeNode:
        def __init__(self, key):
            self.left = None
            self.right = None
            self.val = key
    
    def insert(root, key):
        # 请在这里编写代码
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
  3. Étant donné un graphique, représenté par une matrice de contiguïté, implémentez la recherche en largeur d'abord (BFS).

    def bfs(graph, start):
        # 请在这里编写代码
    
    • 1
    • 2

Répondre

1. Questions à choix multiples

  1. B
  2. UN
  3. B
  4. D
  5. C
  6. B
  7. B
  8. B
  9. UN
  10. UN

2. Remplissez les espaces vides

  1. log(n+1) arrondir à l'inférieur
  2. O(n log n)
  3. Sur)
  4. O(V^2)
  5. La somme des longueurs de chemin pondérées de tous les nœuds feuilles

3. Questions à réponse courte

  1. propriétés de l'arbre rouge noir

    • Propriété 1 : Chaque nœud est rouge ou noir.
    • Propriété 2 : Le nœud racine est noir.
    • Propriété 3 : Chaque nœud feuille (nœud NIL) est noir.
    • Propriété 4 : Si un nœud est rouge, alors ses deux nœuds enfants sont noirs (c'est-à-dire qu'il ne peut pas y avoir deux nœuds rouges consécutifs sur tous les chemins depuis chaque feuille jusqu'à la racine).
    • Propriété 5 : Tous les chemins simples d'un nœud à chacune de ses feuilles contiennent le même nombre de nœuds noirs.

    Comment les arbres rouge-noir maintiennent l'équilibre

    • Après les opérations d'insertion et de suppression, les propriétés de l'arbre rouge-noir sont conservées par rotation et recoloration, garantissant ainsi que la hauteur de l'arbre reste toujours dans la plage O (log n).
  2. La différence entre un tableau dynamique et une liste chaînée

    • Tableaux dynamiques (tels que les listes en Python) : la mémoire est continue, les éléments sont accessibles rapidement via des index, les opérations d'insertion et de suppression nécessitent le déplacement d'éléments et la complexité temporelle est O(n).
    • Liste chaînée : la mémoire n'est pas continue et connectée via des pointeurs (références). La complexité temporelle des opérations d'insertion et de suppression est O(1), mais la complexité temporelle de la recherche d'éléments est O(n).
    • Avantages et inconvénients
      • Tableau dynamique : l'avantage est que l'accès aléatoire est rapide, mais l'inconvénient est que l'insertion et la suppression sont lentes et peuvent nécessiter une extension.
      • Liste chaînée : l'avantage est que l'insertion et la suppression sont rapides, mais l'inconvénient est que l'accès aléatoire est lent et prend plus de mémoire (car les pointeurs doivent être stockés).
    • Scénarios d'application
      • Les tableaux dynamiques conviennent aux scénarios dans lesquels les éléments doivent être consultés fréquemment et la taille n'est pas modifiée fréquemment, comme la mise en cache.
      • Les listes chaînées conviennent aux scénarios nécessitant une insertion et une suppression fréquentes d'éléments, tels que l'implémentation de files d'attente et de piles.
  3. Le principe de la table de hachage

    • Les tables de hachage mappent les clés aux positions d'index du tableau via une fonction de hachage, permettant des opérations de recherche, d'insertion et de suppression rapides.
    • Comment gérer les conflits
      • Méthode d'adresse ouverte : en cas de conflit, la détection linéaire, la détection secondaire et d'autres méthodes sont utilisées pour trouver le prochain emplacement libre.
      • Méthode d'adresse en chaîne : en cas de conflit, les éléments avec la même valeur de hachage sont stockés dans une liste chaînée.

4. Questions de programmation

  1. Déterminez si la liste chaînée est une liste chaînée palindrome :

    class ListNode:
        def __init__(self, x):
            self.val = x
            self.next = None
    
    def is_palindrome(head):
        # 使用快慢指针找到链表中点
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        
        # 反转后半部分链表
        prev = None
        while slow:
            temp = slow.next
            slow.next = prev
            prev = slow
            slow = temp
        
        # 比较前半部分和后半部分
        left, right = head, prev
        while right:
            if left.val != right.val:
                return False
            left = left.next
            right = right.next
        return True
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
  2. Opération d'insertion dans l'arbre de recherche binaire :

    class TreeNode:
        def __init__(self, key):
            self.left = None
            self.right = None
            self.val = key
    
    def insert(root, key):
        if root is None:
            return TreeNode(key)
        if key < root.val:
            root.left = insert(root.left, key)
        else:
            root.right = insert(root.right, key)
        return root
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
  3. Recherche en largeur d'abord (BFS) :

    from collections import deque
    
    def bfs(graph, start):
        visited = [False] * len(graph)
        queue = deque([start])
        visited[start] = True
        result = []
    
        while queue:
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10