Compartilhamento de tecnologia

2025 ~ Perguntas do teste "Estrutura de dados" ~ Exame de admissão à pós-graduação

2024-07-12

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

Página inicial do autor: Zhi Guyun sai de Xiu
Insira a descrição da imagem aqui

  1. Questões de múltipla escolha: Examine conceitos básicos e operações básicas
  2. Preencha os espaços em branco: Fortalecer a compreensão dos principais conceitos e detalhes
  3. perguntas de resposta curta: Testar o domínio do conhecimento teórico
  4. Perguntas de programação: Teste a capacidade real de programação e aplicação de estrutura de dados
  5. Insira a descrição da imagem aqui

Volume de simulação de estrutura de dados

1. Questões de múltipla escolha (2 pontos cada, 20 pontos no total)

  1. A complexidade de tempo de inserção de um elemento em uma matriz é ().
    A.O(1)
    B. O(n)
    C. O(log n)
    D. O(n^2)

  2. Na classificação de heap, a complexidade de tempo de construção de um heap máximo é ().
    A. O(n)
    B. O(n log n)
    C. O(log n)
    D. O(n^2)

  3. Uma árvore rubro-negra é um tipo de ().
    A. Árvore binária completa
    B. Árvore binária balanceada
    C. Min-heap
    D. Pilha máxima

  4. Qual das seguintes afirmações sobre tabelas hash está incorreta ().
    A. A complexidade do tempo de pesquisa da tabela hash é O(1)
    B. A complexidade do tempo de inserção da tabela hash é O(1)
    C. Tabelas hash podem resolver conflitos
    D. A complexidade do tempo de pesquisa da tabela hash deve ser O(1)

  5. Na travessia do gráfico, a complexidade de tempo da pesquisa em profundidade (DFS) e da pesquisa em largura (BFS) são () respectivamente.
    A. O(V + E) e O(V)
    B.O(V^2) e O(V)
    C.O(V + E) e O(V + E)
    D.O(V) e O(V^2)

  6. A complexidade de tempo de reversão de uma lista vinculada unilateral é ().
    A.O(1)
    B. O(n)
    C. O(log n)
    D. O(n^2)

  7. Em uma árvore de pesquisa binária, o pior caso de complexidade de tempo para exclusão de um nó é ().
    A.O(1)
    B. O(n)
    C. O(log n)
    D. O(n log n)

  8. Qual dos seguintes algoritmos de classificação tem uma complexidade de tempo média de O(n log n)().
    A. Classificação por bolha
    B. Classificação rápida
    C. Classificação por inserção
    D. Classificação de seleção

  9. Em uma árvore binária, o grau de um nó é ().
    A. O número de nós filhos deste nó
    B. A profundidade do nó
    C. A altura do nó
    D. O nível do nó

  10. A principal diferença entre a árvore B e a árvore B+ é ().
    A. Todos os nós da árvore B armazenam dados, enquanto apenas os nós folha da árvore B+ armazenam dados.
    B. A árvore B é mais equilibrada que a árvore B+
    C. As operações de inserção e exclusão da árvore B são mais simples
    D. A eficiência de pesquisa da árvore B+ é menor

2. Perguntas para preencher as lacunas (3 pontos cada, 15 pontos no total)

  1. A altura de uma árvore binária completa contendo n nós é ______.
  2. A complexidade média de tempo da classificação rápida é ______.
  3. Em uma lista vinculada, a complexidade de tempo para encontrar o k-ésimo elemento é ______.
  4. A complexidade espacial da representação da matriz de adjacência de um gráfico é ______.
  5. Em uma árvore de Huffman, o comprimento do caminho ponderado é calculado como ______.

3. Perguntas de resposta curta (10 pontos cada, 30 pontos no total)

  1. Descreva brevemente as propriedades das árvores rubro-negras e explique como as árvores rubro-negras mantêm o equilíbrio.
  2. Explique a diferença entre matrizes dinâmicas e listas vinculadas e discuta suas vantagens, desvantagens e cenários de aplicação.
  3. Descrever os princípios das tabelas hash e explicar como lidar com colisões.

4. Questões de programação (15 pontos cada, 35 pontos no total)

  1. Implemente uma função para determinar se uma lista vinculada é uma lista vinculada de palíndromo.

    def is_palindrome(head):
        # 请在这里编写代码
    
    • 1
    • 2
  2. Escreva o código para implementar a operação de inserção na árvore de pesquisa binária.

    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. Dado um gráfico, representado por uma matriz de adjacência, implemente a pesquisa em largura (BFS).

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

Responder

1. Questões de múltipla escolha

  1. B
  2. A
  3. B
  4. E
  5. C
  6. B
  7. B
  8. B
  9. A
  10. A

2. Preencha os espaços em branco

  1. log(n+1) arredondar para baixo
  2. O(n log n)
  3. Sobre)
  4. O(V^2)
  5. A soma dos comprimentos de caminho ponderados de todos os nós folha

3. Perguntas de resposta curta

  1. propriedades da árvore vermelha preta

    • Propriedade 1: Cada nó é vermelho ou preto.
    • Propriedade 2: O nó raiz é preto.
    • Propriedade 3: Cada nó folha (nó NIL) é preto.
    • Propriedade 4: Se um nó for vermelho, então ambos os seus nós filhos serão pretos (ou seja, não pode haver dois nós vermelhos consecutivos em todos os caminhos de cada folha até a raiz).
    • Propriedade 5: Todos os caminhos simples de qualquer nó até cada uma de suas folhas contêm o mesmo número de nós pretos.

    Como as árvores rubro-negras mantêm o equilíbrio

    • Após as operações de inserção e exclusão, as propriedades da árvore rubro-negra são mantidas girando e recolorindo, garantindo assim que a altura da árvore sempre permaneça dentro do intervalo O(log n).
  2. A diferença entre matriz dinâmica e lista vinculada

    • Matrizes dinâmicas (como listas em Python): A memória é contínua, os elementos podem ser acessados ​​rapidamente por meio de índices, as operações de inserção e exclusão requerem elementos móveis e a complexidade de tempo é O(n).
    • Lista vinculada: a memória não é contínua e conectada por meio de ponteiros (referências). A complexidade de tempo das operações de inserção e exclusão é O(1), mas a complexidade de tempo de localização de elementos é O(n).
    • Vantagens e desvantagens
      • Matriz dinâmica: A vantagem é que o acesso aleatório é rápido, mas a desvantagem é que a inserção e a exclusão são lentas e podem exigir expansão.
      • Lista vinculada: A vantagem é que a inserção e a exclusão são rápidas, mas a desvantagem é que o acesso aleatório é lento e ocupa mais memória (porque os ponteiros precisam ser armazenados).
    • Cenários de aplicação
      • Matrizes dinâmicas são adequadas para cenários onde os elementos precisam ser acessados ​​com frequência e o tamanho não é modificado com frequência, como armazenamento em cache.
      • As listas vinculadas são adequadas para cenários que exigem inserção e exclusão frequentes de elementos, como implementação de filas e pilhas.
  3. O princípio da tabela hash

    • As tabelas hash mapeiam chaves para posições de índice de array por meio de uma função hash, permitindo operações rápidas de pesquisa, inserção e exclusão.
    • Como lidar com conflitos
      • Método de endereço aberto: Em caso de conflito, detecção linear, detecção secundária e outros métodos são usados ​​para encontrar o próximo local livre.
      • Método de endereço de cadeia: Quando há um conflito, os elementos com o mesmo valor de hash são armazenados em uma lista vinculada.

4. Questões de programação

  1. Determine se a lista vinculada é uma lista vinculada palíndromo:

    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. Operação de inserção na árvore binária de busca:

    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. Amplitude da primeira pesquisa (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