Aula 08 - Algoritmos e Estruturas de Dados - Listas Ligadas Simples (Python) - V2

Aula 08 – Lista Ligada Simples
• Estrutura de dados dinâmica
• Composta de nós
• Organizados sequencialmente
• Aloca a memória necessária enquanto o programa está executando
• Comportamento dinâmico – pode expandir e reduzir o espaço alocado

facilmente em tempo de execução
• Diferente de Arrays
• Dados não são armazenados em localizações continuas de memória
Algoritmos e Estruturas de Dados 1

• Inserção e remoção
• Fácil – não existe a necessidade de realocar ou reorganizar toda a estrutura
• Arrays – deslocamento de elementos
• Listas Ligadas – não existe o movimento físico dos dados durante a inserção e
remoção de elementos
• ADT – Abstract Data Types
• Listas, pilhas ou filas

• Desvantagens
• Não é possível o acesso aleatório eficiente
• A implementação exige memória extra

• Tipos de Listas Ligadas
• Lista Ligada Simples
• Lista Ligada Dupla / Lista Duplamente Ligada
• Lista Ligada Circular
• Lista Ligada com Nó Cabeça

• Lista Ligada Simples
• Nó de uma lista ligada simples INFO REF
INÍCIO
Variável de referência especial – primeiro nó da lista
10 20 40 15 NULO
• Início – Identidade da lista / Referência que auxilia no acesso a todos os
elementos da lista
• Lista vazia – início = nulo

• Implementação (Python)
1 class No(object): 1 from lista_ligada_simples import ListaLigadaSimples
2 def __init__(self, info): 2
3 def escolherOpcao(escolha):
3 self.info = info 4 opcoes = {
4 self.proximo = None 5 1: listaLigadaSimples.exibirLista()
...
1 class ListaLigadaSimples(object): 6 }
8 return opcoes.get(escolha, "")
2 def __init__(self):
9
3 self.inicio = None 10 def main():
11 listaLigadaSimples = ListaLigadaSimples()
12 listaLigadaSimples.criarLista()
13
14 while(True):
15 print('1. Exibir lista')
16 print('2. Contar o numero de Nos')
17 print('3. Procurar um elemento')
...
33 print('19. Sair')
34
35 escolha = int(input('escolha uma opcao: '))
36
37 if escolha == 19:
38 break
40 escolherOpcao(escolha)
41
42 if __name__ == "__main__":
43 main()

• Percorrer a Lista Ligada Simples
• Visitar cada Nó exatamente uma vez
• Do início / visitar cada Nó até alcançar o último nó
INÍCIO
10 20 30 40 50

• Como se mover através das referências em um lista ligada simples

INÍCIO
p p.proximo
10 20 30 40 50
p = p.proximo

• Como se mover através das referências em um lista ligada simples

INÍCIO
p
10 20 30 40 50
p = p.proximo

• Obtém uma referência para o primeiro Nó

INÍCIO
10 20 30 40 50

• Início faz referência ao primeiro Nó

INÍCIO
p
10 20 30 40 50
No p = inicio
• Enquanto visitar cada Nó, imprime o conteúdo do Nó

INÍCIO
p
10 20 30 40 50
No p = inicio
imprimir(p.info)
Saída: 10


INÍCIO
p
10 20 30 40 50
p = p.proximo
imprimir(p.info)
Saída: 20


INÍCIO
p
10 20 30 40 50
p = p.proximo
imprimir(p.info)
Saída: 30


INÍCIO
p
10 20 30 40 50
p = p.proximo
imprimir(p.info)
Saída: 40


INÍCIO
p
10 20 30 40 50
p = p.proximo
imprimir(p.info)
Saída: 50

• p se torna nulo
INÍCIO
p
10 20 30 40 50
p = p.proximo • Repete as mesmas instruções continuamente

• Usar um laço
• Critério de parada – p igual a nulo

• p se torna nulo
INÍCIO
p
10 20 30 40 50
No p = inicio
enquanto (p diferente Nulo)
imprimir(p.info)
p = p.proximo

• Contar Nós
• Usar o mesmo laço para contar o números de Nós na lista

INÍCIO
p
10 20 30 40 50
n = 0
No p = inicio
equanto (p diferente Nulo)
incrementa n
p = p.proximo
imprimir(‘numero de Nos ’, n)
• Procurar por um elemento na lista
• Buscar o elemento x qualquer

INÍCIO
p
10 20 30 40 50
posicao = 1 • Ao visitar um Nó, verificar info do Nó

No p = inicio • Se info do Nó for igual a x
equanto (p diferente Nulo) • Encerra a execução e sai do laço
se p.info igual x • Critérios de parada
encerra • x é encontrado – encerra a execução
incrementa posicao • x não existe na lista – alcançou o final da lista e p se torna
p = p.proximo nulo

• Procurar por um elemento na lista
• Buscar o elemento x qualquer

INÍCIO
p
10 20 30 40 50
se p igual nulo • posicao fornece a localização do elemento procurado que

imprime(x, ‘ nao encontrado’) possui x
senao
imprime(x, ‘ encontrado na posicao ’, posicao)

•6 if self.inicio is None:
5 def exibirLista(self): 30 def procurarElemento(self, info):
)
7 print('lista vazia')
31 posicao = 1
32 p = self.inicio
8 return 33
9 34 while (p is not None):
10 print('lista ') 35 if (p.info == info):
11 36 break
12 p = self.inicio 37 posicao += 1
13 38 p = p.proximo
14 while (p is not None): 39
15 print(p.info + ' ') 40 if p is None:
16 p = p.proximo 41 print('%s nao encontrado na lista' % info)
17 42
18 print() 43 return False
44 else:
45 print('%s encontrado na posicao %s' % (info, posicao))
20 def contarNumeroNos(self): 46
21 n = 0 47 return True
22 p = self.inicio
23
24 while (p is not None):
25 n += 1
26 p = p.proximo
27
28 print('numero de nos na lista eh ', n)

• Encontrando referências em um Lista Ligada
• Como navegar na lista ligada
• Encontrar uma referência para o último nó
• Encontrar uma referência para o anterior ao último nó
• Encontrar uma referência para o nó com uma informação particular
• Encontrar uma referência para o predecessor de um nó com uma informação

particular
• Encontrar uma referência para um nó em uma posição particular

• Encontrar uma referência para o último nó

INÍCIO
p
10 20 30 40 50
No p = inicio
equanto (p.proximo diferente Nulo)
p = p.proximo

• Encontrar uma referência para o anterior ao último nó

INÍCIO
p
10 20 30 40 50
No p = inicio
equanto (p.proximo.proximo diferente Nulo)
p = p.proximo

• Encontrar uma referência para o nó com uma informação particular

INÍCIO
p
10 20 30 40 50
No p = inicio • x = 30
equanto (p diferente Nulo) • Se p é nulo -> x não existe na lista
if (p.info igual x)
encerra
p = p.proximo

• Encontrar uma referência para o predecessor de um nó com uma informação particular
INÍCIO
p
10 20 30 40 50
No p = inicio • x = 30
equanto (p.proximo diferente Nulo) • p.proximo.info é 30, logo encerra o laço
if (p.proximo.info igual x) enquanto
encerra
p = p.proximo

• Encontrar uma referência para um nó em uma posição particular

INÍCIO
p
1 2 3 4 5
10 20 30 40 50
No p = inicio • Posição x = 3
para (i igual 1; i menor x, p diferente Nulo; incrementa i)
p = p.proximo

• Inserir em uma Lista Ligada Simples
• Inserir no inicio temp
• Inserir em um lista vazia
• Inserir no final
• Inserir novo No entre elementos
// Construtor da classe No • No temp = novo No(info)

No(i)
info = i
próximo = Nulo

• Inserir no inicio da Lista

INÍCIO
temp
temp.proximo = inicio
inicio = temp

• Inserir no inicio da Lista (Incorreto)

INÍCIO
temp
inicio = temp
temp.proximo = inicio

• Inserir em um lista vazia

INÍCIO
temp
inicio = temp

• Inserir no final da lista

INÍCIO
p
temp
P = inicio
enquanto (p.proximo diferente Nulo)
p = p.proximo
p.proximo = temp

• Inserir novo No entre elementos

INÍCIO
p
temp
temp.próximo = p.proximo
p.proximo = temp

• Inserir novo No entre elementos (Incorreto)

INÍCIO
p
temp
p.proximo = temp
temp.próximo = p.proximo

• Inserir depois de um elemento especificado
• Inserir antes de um elemento especificado
• Inserir em uma posição especifica
• Mesmo procedimento para os três caso
• Difere apenas na maneira de encontrar a referência p

• Inserir depois de um elemento especificado

INÍCIO • Inserir um novo nó após o nó com a
p informação x
• x = 56
32 56 21 45 72
temp 10
p = inicio temp.proximo = p.proximo

enquanto (p diferente Nulo) p.proximo = temp
if (p.info igual x)
encerra
p = p.proximo

• Inserir antes de um elemento especificado

INÍCIO • Inserir um novo nó antes do nó com
p a informação x
• x = 45
32 56 21 45 72
temp 10

enquanto (p.proximo diferente Nulo) p.proximo = temp
if (p.proximo.info igual x)
encerra
p = p.proximo

• Inserir em uma posição especificada

INÍCIO • Inserir um novo nó na posição x da
p lista
• x = 4
1 2 3 5
4 65
32 56 21 45 72
4
temp 10

para (i = 1; i < x – 1, p diferente Nulo; incrementa i) p.proximo = temp
p = p.proximo

Aula 08 – Lista Ligada Simples (Python)
• Implementação do Inserir em uma Lista Ligada Simples
def inserirInicio(self, info): def inserirFim(self, info):
temp = No(info) temp = No(info)
temp.proximo = self.inicio
self.inicio = temp if (self.inicio is None):
self.inicio = temp

return

p = self.inicio
while (p.proximo is not None):
p = p.proximo

p.proximo = temp

def inserirDepois(self, info, x): def inserirAntes(self, info, x):
# lista esta vazia
p = self.inicio if (self.inicio is None):
print('lista esta vazia')
while (p is not None): return
if (p.info == x):
# x eh o primeiro no
break # o novo elemento sera inserido antes do
primeiro no
p = p.proximo if (x == self.inicio):
temp = No(info)
if (p is None): self.inicio = temp
print(str(x) + 'nao foi encontrado na lista') return
else:
temp = No(info) # encontra a referencia para o predecessor
do elemento que contem x
temp.proximo = p.proximo p = self.inicio
p.proximo = temp while (p.proximo is not None):
if (p.proximo.info == x):
break
p = p.proximo

if (p.proximo is None):
print(str(x) + ' nao encontrado na lista')
else:
temp = No(info)
temp.proximo = p.proximo
p.proximo = temp

def inserirPosicao(self, info, x):
if (x == 1):
temp = No(info)
self.inicio = temp
return
p = self.inicio
# encontra a referencia para o no x - 1

for i in range(1, x):
if (p.proximo is not None):
p = p.proximo
else:
break

if (p is None):
print('so eh possivel inserir ate a ‘ +
str(i) + ' posicao')
else:
temp = No(info)
temp.proximo = p.proximo
p.proximo = temp

• Remoção em uma Lista Ligada Simples
• Remoção do primeiro nó
• Remoção do único nó
• Remoção no interior da lista
• Remoção do final da lista

• Remoção do primeiro nó
INÍCIO
10 20 30 40 50
inicio = inicio.próximo

• Remoção do único nó
INÍCIO
10
inicio = Nulo

• Remoção no interior da lista

INÍCIO
p
10 20 30 40 50
p.proximo = p.proximo.proximo • Necessita uma referência ao predecessor

• Remoção do final da lista

INÍCIO
p
10 20 30 40 50
p.proximo = Nulo • Necessita uma referência ao antecessor

do último nó

151 def removerPrimeiro(self): 173 def remover(self, info):
152 if (self.inicio is None): 174 if (self.inicio is None):
153 return 175 print('lista vazia')
154 176
155 self.inicio = self.inicio.proximo 177 return
178
179 # remocao do primeiro no
157 def removerUltimo(self): 180 if (self.inicio.info == info):
158 if (self.inicio is None): 181 self.inicio = self.inicio.proximo
159 return 182
160 183 return
161 if (self.inicio.proximo is None): 184
162 self.inicio = None 185 # remocao no interior ou no final da lista
163 186 p = self.inicio
164 return 187
165 188 while (p.proximo is not None):
166 p = self.inicio 189 if (p.proximo.info == info):
167 190 break
168 while (p.proximo.proximo is not None): 191
169 p = p.proximo 192 p = p.proximo
170 193
171 p.proximo = None 194 if (p.proximo is None):
195 print('elemento ' + str(x) + ' nao localizado na lista')
196 else:
197 p.proximo = p.proximo.próximo

• Inversão de uma Lista Ligada Simples
INÍCIO
10 20 30 40 50
INÍCIO
10 20 30 40 50

INÍCIO ant = Nulo prox = Nulo
ant
p ant
prox ant
prox ant
prox ant
prox
10 20 30 40 50
p
p p p p
anterior = Nulo • Necessita 3 referências
P = inicio • anterior, p, proximo
enquanto (p diferente Nulo)

proximo = p.proximo
p.proximo = anterior
anterior = p
p = proximo
inicio = anterior

199 def inverterLista(self):
200 anterior = None
201 p = self.inicio
202
204 proximo = p.proximo
205 p.proximo = anterior
206 anterior = p
207 p = proximo
208
209 self.inicio = anterior

• Implementação de Lista Ligada Simples
1 from no import No 22 def contarNumeroNos(self):
2 23 n = 0
3 class ListaLigadaSimples(object): 24 p = self.inicio
4 def __init__(self): 25
5 self.inicio = None 26 while (p is not None):
6 27 n += 1
7 def exibirLista(self): 28 p = p.proximo
8 if self.inicio is None: 29
9 print('lista vazia') 30 print('numero de nos na lista eh ', n)
10 return
11
12 print('lista ')
13
14 p = self.inicio
15
17 print(str(p.info) + ' ')
18 p = p.proximo
19
20 print()

32 def procurarElemento(self, info): 51 def inserirInicio(self, info):
33 posicao = 1 52 temp = No(info)
34 p = self.inicio 53 temp.proximo = self.inicio
35 54 self.inicio = temp
36 while (p is not None): 55
37 if (p.info == info): 56 def inserirFim(self, info):
38 break 57 temp = No(info)
39 posicao += 1 58
40 p = p.proximo 59 if (self.inicio is None):
41 60 self.inicio = temp
42 if p is None: 61
43 print('%s nao encontrado na lista’ % 62 return
info) 63
44 64 p = self.inicio
45 return False 65 while (p.proximo is not None):
46 else: 66 p = p.proximo
47 print('%s encontrado na posicao %s’ % 67
(info, posicao)) 68 p.proximo = temp
48
49 return True


70 def criarLista(self): 80 def inserirDepois(self, info, x):
71 n = int(input('entre com o numero de 81 p = self.inicio
elementos: ')) 82
72 83 while (p is not None):
73 if (n == 0): 84 if (p.info == x):
74 return 85 break
75 86
76 for i in range(1, n + 1): 87 p = p.proximo
77 info = int(input('entre com o 88
elemento que sera inserido: ')) 89 if (p is None):
78 self.inserirFim(info) 90 print(str(x) + 'nao foi encontrado
na lista')
91 else:
92 temp = No(info)
93 temp.proximo = p.proximo
94 p.proximo = temp


96 def inserirAntes(self, info, x): 127 def inserirPosicao(self, info, x):
97 # lista esta vazia 128 if (x == 1):
98 if (self.inicio is None): 129 temp = No(info)
99 print('lista esta vazia')
130 temp.proximo = self.inicio
101 return
131 self.inicio = temp
102
103 # x eh o primeiro no 132
104 # o novo elemento sera inserido antes do 133 return
primeiro no 134
105 if (x == self.inicio): 135 p = self.inicio
106 temp = No(info) 136
107 temp.proximo = self.inicio 137 # encontra a referencia para o no x - 1
108 self.inicio = temp 138 for i in range(1, x):
110 return 139 if (p.proximo is not None):
111
140 p = p.proximo
112 # encontra a referencia para o predecessor
do elemento que contem x 141 else:
113 p = self.inicio 142 break
114 while (p.proximo is not None): 143
115 if (p.proximo.info == x): 144 if (p is None):
116 break 145 print('so eh possivel inserir ate a ’ +
118 p = p.proximo str(i) + ' posicao')
119 146 else:
120 if (p.proximo is None): 147 temp = No(info)
121 print(str(x) + ' nao encontrado na
lista')
122 else: 149 p.proximo = temp
123 temp = No(info)
125 p.proximo = temp


151 def removerPrimeiro(self): 173 def remover(self, info):
152 if (self.inicio is None): 174 if (self.inicio is None):
153 return 175 print('lista vazia')
154 176
155 self.inicio = self.inicio.proximo 177 return
156 178
157 def removerUltimo(self): 179 # remocao do primeiro no
158 if (self.inicio is None): 180 if (self.inicio.info == info):
159 return 181 self.inicio = self.inicio.proximo
160 182
161 if (self.inicio.proximo is None): 183 return
162 self.inicio = None 184
163 185 # remocao no interior ou no final da lista
164 return 186 p = self.inicio
165 187
166 p = self.inicio 188 while (p.proximo is not None):
167 189 if (p.proximo.info == info):
168 while (p.proximo.proximo is not None): 190 break
169 p = p.proximo 191
170 192 p = p.proximo
171 p.proximo = None 193
194 if (p.proximo is None):
195 print('elemento ' + str(info) +
' nao localizado na lista')
196 else:
197 p.proximo = p.proximo.próximo

199 def inverterLista(self):
200 anterior = None
201 p = self.inicio
202
204 proximo = p.proximo
205 p.proximo = anterior
206 anterior = p
207 p = proximo
208
209 self.inicio = anterior

• Implementação de Lista Ligada Simples (Demonstração)
1 from lista_ligada_simples import ListaLigadaSimples 29 def inserirInicio():
2 30 info = int(input('entre com a informacao que deseja inserir: '))
3 listaLigadaSimples = ListaLigadaSimples() 31 listaLigadaSimples.inserirInicio(info)
4 32
5 def escolherOpcao(escolha): 33 def inserirFim():
6 opcoes = { 34 info = int(input('entre com a informacao que deseja inserir: '))
7 1: listaLigadaSimples.exibirLista, 35 listaLigadaSimples.inserirFim(info)
8 2: listaLigadaSimples.contarNumeroNos, 36
9 3: procurarElemento, 37 def inserirDepois():
10 4: inserirInicio, 38 info = int(input('entre com a informacao que deseja inserir: '))
11 5: inserirFim, 39 x = int(input('entre com o elemento que vira antes do novo no: '))
12 6: inserirDepois, 40 listaLigadaSimples.inserirDepois(info, x)
13 7: inserirAntes, 41
14 8: inserirPosicao, 42 def inserirAntes():
15 9: listaLigadaSimples.removerPrimeiro, 43 info = int(input('entre com a informacao que deseja inserir: '))
16 10: listaLigadaSimples.removerUltimo, 44 x = int(input('entre com o elemento que vira depois do novo no: ')
17 11: remover, )
18 12: listaLigadaSimples.inverterLista, 45 listaLigadaSimples.inserirAntes(info, x)
21 } 46
22 47 def inserirPosicao():
23 opcoes.get(escolha, "")() 48 info = int(input('entre com a informacao que deseja inserir: '))
24 49 x = int(input('entre com a posicao onde sera inserido o novo no: '
25 def procurarElemento(): ))
26 info = int(input('entre com a informacao que deseja procurar: ')) 50 listaLigadaSimples.inserirPosicao(info, x)
27 listaLigadaSimples.procurarElemento(info) 51
52 def remover():
53 info = int(input('entre com a informacao que deseja remover: '))
54 listaLigadaSimples.remover(info)


• Implementação de Lista Ligada Simples (Demonstração)
56 def main():
57
58 listaLigadaSimples.criarLista()
59
60 while(True):
61 print('1. Exibir lista')
62 print('2. Contar o numero de Nos')
63 print('3. Procurar um elemento')
64 print('4. Inserir em lista vazia /
Inserir no inicio da lista')
65 print('5. Inserir um novo No no final da lista')
66 print('6. Inserir depois de um No especificado')
67 print('7. Inserir um novo No antes de um No especificado')
68 print('8. Inserir um No em uma posicao especificada')
69 print('9. Remover o primeiro elemento')
70 print('10. Remover o ultimo elemento')
71 print('11. Remover um elemento especificado')
72 print('12. Inverter a lista')
79 print('19. Sair')
80
81 escolha = int(input('escolha uma opcao: '))
83
84 if (escolha == 19):
85 break
87 escolherOpcao(escolha)
88
89 if __name__ == "__main__":
90 main()

Aula 08 - Algoritmos e Estruturas de Dados - Listas Ligadas Simples (Python) - V2

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Aula 08 - Algoritmos e Estruturas de Dados - Listas Ligadas Simples (Python) - V2

Enviado por

Direitos autorais:

Formatos disponíveis

Aula 08 – Lista Ligada Simples

• Estrutura de dados dinâmica

• Aloca a memória necessária enquanto o programa está executando

• Comportamento dinâmico – pode expandir e reduzir o espaço alocado

• Dados não são armazenados em localizações continuas de memória

Algoritmos e Estruturas de Dados 1

• Fácil – não existe a necessidade de realocar ou reorganizar toda a estrutura

• Arrays – deslocamento de elementos

• Listas, pilhas ou filas

Algoritmos e Estruturas de Dados 2

• Não é possível o acesso aleatório eficiente

• A implementação exige memória extra

Algoritmos e Estruturas de Dados 3

• Lista Ligada Simples

• Lista Ligada Dupla / Lista Duplamente Ligada

• Lista Ligada Circular

• Lista Ligada com Nó Cabeça

Algoritmos e Estruturas de Dados 4

• Nó de uma lista ligada simples INFO REF

Algoritmos e Estruturas de Dados 5

Algoritmos e Estruturas de Dados 7

• Visitar cada Nó exatamente uma vez

• Do início / visitar cada Nó até alcançar o último nó

Algoritmos e Estruturas de Dados 8

• Como se mover através das referências em um lista ligada simples

Algoritmos e Estruturas de Dados 9

• Como se mover através das referências em um lista ligada simples

Algoritmos e Estruturas de Dados 10

• Obtém uma referência para o primeiro Nó

Algoritmos e Estruturas de Dados 11

• Início faz referência ao primeiro Nó

• Enquanto visitar cada Nó, imprime o conteúdo do Nó

Algoritmos e Estruturas de Dados 13

• Enquanto visitar cada Nó, imprime o conteúdo do Nó

Algoritmos e Estruturas de Dados 14

• Enquanto visitar cada Nó, imprime o conteúdo do Nó

Algoritmos e Estruturas de Dados 15

• Enquanto visitar cada Nó, imprime o conteúdo do Nó

Algoritmos e Estruturas de Dados 16

• Enquanto visitar cada Nó, imprime o conteúdo do Nó

Algoritmos e Estruturas de Dados 17

p = p.proximo • Repete as mesmas instruções continuamente

Algoritmos e Estruturas de Dados 18

Algoritmos e Estruturas de Dados 19

• Usar o mesmo laço para contar o números de Nós na lista

• Buscar o elemento x qualquer

posicao = 1 • Ao visitar um Nó, verificar info do Nó

Algoritmos e Estruturas de Dados 21

• Buscar o elemento x qualquer

se p igual nulo • posicao fornece a localização do elemento procurado que

Algoritmos e Estruturas de Dados 22

Algoritmos e Estruturas de Dados 24

• Como navegar na lista ligada

• Encontrar uma referência para o último nó

• Encontrar uma referência para o anterior ao último nó

• Encontrar uma referência para o nó com uma informação particular

• Encontrar uma referência para o predecessor de um nó com uma informação

Algoritmos e Estruturas de Dados 25

• Encontrar uma referência para o último nó

Algoritmos e Estruturas de Dados 26

• Encontrar uma referência para o anterior ao último nó

Algoritmos e Estruturas de Dados 27

• Encontrar uma referência para o nó com uma informação particular