class ListaSimples:
def __init__(self):
self.cabeca = No(None)
def esta_vazia(self):
return self.cabeca.get_proximo() == None
def adicionar(self, novo_no):
if(self.esta_vazia()):
self.cabeca.set_proximo(novo_no)
else:
atual = self.cabeca
while(atual.get_proximo()):
atual = atual.get_proximo()
atual.set_proximo(novo_no)
def percorrer(self):
atual = self.cabeca.get_proximo()
while(atual):
print(atual.get_elemento())
atual = atual.get_proximo()
def bfs(estado_inicial,
testar_objetivo,
gerar_sucessores,
imprimir=str,
stepEstado=False,
stepSucessores=False):
fila = Fila()
fila.push(No(estado_inicial))
visitados = {estado_inicial} # Conjuntos (Sets) em python e {1, 2, 3}
while not fila.esta_vazio():
no_atual = fila.pop()
estado_atual = no_atual.estado
if stepEstado: imprime_atual(estado_atual, imprimir)
# faz o teste objetivo conforme a função `teste_objetivo`
# para a execução se achou o objetivo
if (testar_objetivo(estado_atual)):
return no_atual
# verifico os nos filhos e os adiciono na fila
# função sucessores define os estados seguintes e adiciona os nós seguintes
estados_vertices_sucessores = gerar_sucessores(estado_atual)
if stepSucessores:
imprime_sucessores(estados_vertices_sucessores, imprimir)
for estados_vertices_sucessor in estados_vertices_sucessores:
estado_filho = estados_vertices_sucessor[0]
vertice = estados_vertices_sucessor[1]
if estado_filho in visitados: # pula estado_filho se já foi expandido
continue
visitados.add(estado_filho)
fila.push(No(estado_filho, no_atual, vertice))
def inserir(self, index, Novoelemento):
# cria o nó com o novo elemento
no = No(Novoelemento)
#Se quiser inserir na primeira posição da lista
if index == 0:
# O item de inicio da lista (não atualizada) se torna o no.proximo
no.proximo = self.inicio
#Atualiza o inicio da lista para o nó que entrou
self.inicio = no
#se quiser inserir numa posição diferente de 0
else:
#ponteiro começa na primeira posição
#ponteiro = self.inicio
#O -1 é para que possamos inserir após seu precessor, no local correto da lista
#for item in range(index - 1):
#se o ponteiro não está numa posição vazia(none), último da lista
#if ponteiro:
#O ponteiro "anda" para o próximo da lista
#ponteiro = ponteiro.proximo
#else:
#raise IndexError("Index fora do intervalo da Lista")
#A parte acima do código virou a função a parte getNo()
#O -1 garante que o item a ser incerido fique na posição correta
ponteiro = self.getNo(index - 1)
#garante que os próximos valores serão "apontados"
no.proximo = ponteiro.proximo
ponteiro.next = no
#aumenta o tamanho da lista em 1
self.tamanho += 1
def add(self, item):
aux = No(item)
if self._topo is None:
self._topo = aux
return True
aux.set_proximo(self._topo)
self._topo = aux
return True
def adicionar(self, valor):
if self.inicio:
ponteiro = self.inicio
while(ponteiro.proximo):
ponteiro = ponteiro.proximo
ponteiro.proximo = No(valor)
else:
self.inicio = No(valor)
self.tamanho = self.tamanho +1
def add(self, nome, matricula, curso):
p = No(nome, matricula, curso)
if self.__topo == None:
self.__topo = p
else:
p.set_proximo(self.__topo)
self.__topo = p
def add_inicio(self, item):
aux = No(item)
if self._cabeca is None:
self._cabeca = self._cauda = aux
self.count()
return True
aux.set_proximo(self._cabeca)
self._cabeca = aux
self.count()
return True
def load_graph(self, path):
graph = open(path, "r")
text = ""
for line in graph:
formated_input = self.__format_string(line)
no = No(formated_input[0])
no.neighbors = formated_input[1]
text += GRAU.format(formated_input[0], len(formated_input[1]))
self.graph.append(no)
self.label2.configure(text=text)
def adicionar(self, dado):
no = No(dado)
if self.tamanho == 0:
self.fim = no
else:
no.anterior = self.fim
self.fim = no
self.tamanho += 1
def inserir(self, index, Novoelemento):
no = No(Novoelemento)
if index == 0:
no.proximo = self.inicio
self.inicio = no
else:
ponteiro = self.getNo(index-1)
no.proximo = ponteiro.proximo
ponteiro.next = no
self.tamanho += 1
def add_meio(self, item, pos):
aux = No(item)
p = q = self._cabeca
for i in range(pos):
p = p.get_proximo()
q = p.get_proximo()
aux.set_proximo(q)
p.set_proximo(aux)
self.count()
return True
def push(self, elemento):
"""
insere elementos na pilha
:param elemento: elemento a ser inserido
"""
no = No(elemento)
no.next = self.topo #registra a posição do elemento anterior
self.topo = no
self._size = self._size + 1
def insert(self, index, elem):
last = self.head
no = No(elem)
pos = index - 1
pos = int(pos)
if pos == 0:
no.set_proximo(self.head)
self.head = no
print(f'Elemento adicionado na primeira posição: {self.head}')
self.size += 1
elif pos > self.size:
print(f'A posição {index}, não existe.')
answer = input('Deseja adicionar no final da lista? [S/N] ')
if answer == 'S':
while last.get_proximo():
last = last.get_proximo()
last.next = No(elem)
self.size += 1
print(f'Elemento: {elem} adicionado ao final da lista.')
else:
print('OKAY')
else:
pointer = self._getnode(pos - 1)
no = No(elem)
aux = pointer.get_proximo()
no.set_proximo(aux)
pointer.set_proximo(no)
print(f'Elemento: {elem} adicionado na posição {pos + 1}')
self.size += 1
def addFirst(self, dado):
no = No(dado)
if self.head == None:
self.tail = no
else:
no.proximo = self.head
self.head.anterior = no
self.head = no
no.indice += 1
def type(self):
type = No()
if self.conferirToken([Tag.KW_NUM]):
type.tipo = Tag.TIPO_NUMERO
self.advance()
elif self.conferirToken([Tag.KW_CHAR]):
type.tipo = Tag.TIPO_LITERAL
self.advance()
else:
self.sinalizaErroSintatico("Aguardando 'num' ou 'char'")
return type
def factorB(self):
factorB = No()
factorA = self.factorA()
factorBLinha = self.factorBLinha()
if factorBLinha.tipo == Tag.TIPO_VAZIO:
factorB.tipo = factorA.tipo
elif factorBLinha.tipo == factorA.tipo and factorBLinha.tipo == Tag.TIPO_NUMERO:
factorB.tipo = Tag.TIPO_NUMERO
else:
factorB.tipo = Tag.TIPO_ERRO
return factorB
def constant(self):
constant = No()
if self.conferirToken([Tag.NUM_CONST]):
constant.tipo = Tag.TIPO_NUMERO
self.advance()
elif self.conferirToken([Tag.CHAR_CONST]):
constant.tipo = Tag.TIPO_LITERAL
self.advance()
else:
self.sinalizaErroSintatico("Constante esperada'")
return constant
def simpleExpr(self):
simpExp = No()
term = self.term()
simExpLinha = self.simpleExprLinha()
if simExpLinha.tipo == Tag.TIPO_VAZIO:
simpExp.tipo = term.tipo
elif simExpLinha.tipo == term.tipo and simExpLinha.tipo == Tag.TIPO_NUMERO:
simpExp.tipo = Tag.TIPO_LOGICO
else:
simpExp.tipo = Tag.TIPO_ERRO
return simpExp
def term(self):
term = No()
factoB = self.factorB()
termLinha = self.termLinha()
if termLinha.tipo == Tag.TIPO_VAZIO:
term.tipo = factoB.tipo
elif termLinha.tipo == factoB.tipo and termLinha.tipo == Tag.TIPO_NUMERO:
term.tipo = Tag.TIPO_NUMERO
else:
term.tipo = Tag.TIPO_ERRO
return term
def expression(self):
noExp = No()
noSimpleExp = self.simpleExpr()
noExpLinha = self.expressionLinha()
if noExpLinha.tipo == Tag.TIPO_VAZIO:
noExp.tipo = noSimpleExp.tipo
elif noExpLinha.tipo == noSimpleExp.tipo and noSimpleExp.tipo == Tag.TIPO_LOGICO:
noExp.tipo = Tag.TIPO_LOGICO
else:
noExp.tipo = Tag.TIPO_ERRO
return noExp
def _inserir(self, chave, val, noCorrente):
# valor chave do nó é menor doque o atual nó
if chave < noCorrente.chave:
if noCorrente.temFilhoEsquerda():
self._inserir(chave, val, noCorrente.esquerda)
else:
noCorrente.esquerda = No(chave, val, pai = noCorrente)
else:
if noCorrente.temFilhoDireita():
self._inserir(chave, val, noCorrente.direita)
else:
noCorrente.direita = No(chave, val, pai = noCorrente)
def expansao(n):
expand = []
## Antes de retornar, setta o pai dos nos expandidos como o no que chegou
for x in mapa:
x = No(x)
if x != n.estado:
x.pai = n
x.caminho2 = n.caminho2 + [n.estado]
expand.append(x)
random.shuffle(expand)
return expand
def adicionar(self, valor):
no = No(valor)
if self.inicio:
ponteiro = self.inicio
while (ponteiro.proximo):
ponteiro = ponteiro.proximo
ponteiro.proximo = no
no.anterior = ponteiro
self.fim = no
else:
self.inicio = no
self.fim = no
self.tamanho += 1
def factorBLinha(self):
factorBlinha = No()
if self.conferirToken([Tag.OP_DIV, Tag.OP_MUL]):
self.mulop()
factorA = self.factorA()
factorBlinhaFilho = self.factorBLinha()
if factorBlinhaFilho.tipo == Tag.TIPO_VAZIO and factorA.tipo == Tag.TIPO_NUMERO:
factorBlinha.tipo = Tag.TIPO_NUMERO
elif factorBlinhaFilho.tipo == factorA.tipo and factorA.tipo == Tag.TIPO_NUMERO:
factorBlinha.tipo = Tag.TIPO_NUMERO
else:
factorBlinha.tipo = Tag.TIPO_ERRO
return factorBlinha
def expressionLinha(self):
expLinha = No()
if self.conferirToken([Tag.KW_OR, Tag.KW_AND]):
self.logop()
simpleExpres = self.simpleExpr()
exprLinhaFilho = self.expressionLinha()
if exprLinhaFilho.tipo == Tag.TIPO_VAZIO and simpleExpres.tipo == Tag.TIPO_LOGICO:
expLinha.tipo = Tag.TIPO_LOGICO
elif exprLinhaFilho.tipo == simpleExpres.tipo and simpleExpres.tipo == Tag.TIPO_LOGICO:
expLinha.tipo = Tag.TIPO_LOGICO
else:
expLinha.tipo = Tag.TIPO_ERRO
return expLinha
def termLinha(self):
termLinha = No()
if self.conferirToken([Tag.OP_AD, Tag.OP_MIN]):
self.addOp()
factorB = self.factorB()
termLinhaFilho = self.termLinha()
if termLinhaFilho.tipo == Tag.TIPO_VAZIO and factorB.tipo == Tag.TIPO_NUMERO:
termLinha.tipo = Tag.TIPO_NUMERO
elif termLinhaFilho == factorB.tipo and factorB.tipo == Tag.TIPO_NUMERO:
termLinha.tipo = Tag.TIPO_NUMERO
else:
termLinha.tipo = Tag.TIPO_ERRO
return termLinha
def append(self, elem):
if self.head:
# INSERÇÃO COM A LISTA POSSUINDO ELEMENTOS
pointer = self.head
while pointer.get_proximo():
pointer = pointer.get_proximo()
pointer.next = No(elem)
print(f'Elemento: {elem} adicionado ao final da lista.')
else:
# INSERÇÃO NO TOPO - LISTA VAZIA
self.head = No(elem)
print(f'Primeiro elemento da lista: {elem}')
self.size += 1
def adicionar(self, valor):
#se a lista não estiver vazia
if self.inicio:
#inserção quando a lista já possui elementos
ponteiro = self.inicio
while (ponteiro.proximo):
ponteiro = ponteiro.proximo
ponteiro.proximo = No(valor)
else:
#self.inicio terá apenas uma referência para o objeto
self.inicio = No(valor)
#incrementa em um o tamanho da lista
self.tamanho = self.tamanho + 1
def factorA(self):
factorA = No()
if self.conferirToken([Tag.KW_NOT]):
self.advance()
factor = self.factor()
if factor.tipo != Tag.TIPO_LOGICO:
factorA.tipo = Tag.TIPO_ERRO
else:
factorA.tipo = Tag.TIPO_LOGICO
else:
factor = self.factor()
factorA.tipo = factor.tipo
return factorA
def factor(self):
factor = No()
if self.conferirToken([Tag.ID]):
factor.tipo = self.lexer.ts.getType(self.token.lexema)
self.advance()
elif self.conferirToken([Tag.SMB_OPA]):
self.eat(Tag.SMB_OPA)
factor = self.expression()
self.eat(Tag.SMB_CPA)
elif self.conferirToken([Tag.NUM_CONST, Tag.CHAR_CONST]):
factor = self.constant()
else:
self.sinalizaErroSintatico("Fator inválido")
return factor
