Esempio n. 1
0
    def topo(self):
        """A raiz da árvore.
        Escrita: ✗

        Erro
           :exception FalhaNaOperacao se o heap estiver vazio.
        """
        if self.vazio:
            raise FalhaNaOperacao('O heap está vazio.')
        return self._raiz.item
Esempio n. 2
0
    def filhoDireito(self, item):
        """Retorna o filho a direita do item.

        Erros
            :exception ItemNaoEncontrado se o item não for localizado.

            :exception FalhaNaOperacao se o item não possuir um filho a
            direita.
        """
        nodo = self._nodo(item).direito

        if nodo is None:
            raise FalhaNaOperacao(f'{item} não possui filho a direita.')
        return nodo.item
Esempio n. 3
0
    def arvoreCoberturaMinima(self):
        """Retorna um novo grafo que representa a árvore de cobertura mínima
        de self.

        O grafo deve ser conexo, não orientado e ponderado.
        Este método considera as distâncias entre os itens para determinar a
        árvore desejada, tais distâncias podem ser informadas através do
        método ligar(a, b, **info), basta informar o par 'distancia=x',
        sendo x um int ou um float, pelo 3º parâmetro.
        É possível que algumas ligações não tenham a distância informada e
        mesmo assim o método retornar normalmente, deste de que seja
        possível determinar a árvore.

        Erros
           :exception Exception se o grafo não for conexo

           :exception FalhaNaOperacao se uma das ligações não tiver a
           distância informada e impossibilitar a determinação da
           árvore de cobertura mínima, ou se o grafo possuir ligações
           orientadas.

        """
        if self.totalDeLigacoesOrientadas > 0:
            raise FalhaNaOperacao('O grafo deve ser não orientado.')

        conjuntos = [{}]
        novasLigacoes = []
        ligacoes = self._ligacoes()

        while len(conjuntos[0]) < len(self._vertices):
            l = ligacoes.remover()
            conjuntoV1 = self._conjunto(l[0], conjuntos)
            conjuntoV2 = self._conjunto(l[2], conjuntos)

            if 'distancia' not in l[1]:
                raise FalhaNaOperacao

            if conjuntoV1 is not conjuntoV2 and l[0] != l[2]:
                novasLigacoes.append(l)
                conjuntos.insert(0, conjuntoV1 + conjuntoV2)

        return self._novoGrafo(novasLigacoes)
Esempio n. 4
0
    def inserir(self, item, pai=NAO_INFORMADO):
        """Insere o item na árvore.

        Parâmetros
           :param item -> o item que será inserido

           :param pai -> o pai do item, se a árvore estiver vazia ele não
           precisa ser informado, caso contrário, deve ser especificado.
           O pai deve possuir menos de 2 filhos.

        Exceções
           :exception ItemNaoEncontradoErro se o pai não for encontrado na
           árvore.

           :exception ParametroNaoEspecificadoErro se a árvore não estiver
           vazia e o pai não tiver sido informado.

           :exception FalhaNaOperacao se o pai já possuir 2 filhos.
        """
        if pai != NAO_INFORMADO and len(super().filhos(pai)) == 2:
            raise FalhaNaOperacao(f'{pai} já possui 2 filhos.')
        super().inserir(item, pai)