Listas Lineares

William Malvezzi, MSc

William Malvezzi, MSc

Listas lineares

Estudo de listas lineares e das operações básicas sobre elas, considerando as diferentes formas de implementação física

Uma Lista Linear (LL) é uma sequênciasequência de nodos

Lista linear

• Nodos - elementos do mesmo tipoNodos - • Relação de ordem linear (ou total)_{Relação de ordem}

Lista linear

a

b

c

d

e

Primeiro nodo Último nodo

• Estrutura interna é abstraída

• Pode ter uma complexidade arbitrária

• Enfatizado o conjunto de relações existente

z

a

b

c

INFORMAÇÕES

Número RG Nome Nasc. Cargo

d

Estrutura dos nodos

Uma lista linear é uma coleção de n ≥ 0 nodos x₁, x₂, ... , x_n, todos do mesmo tipo, cujas propriedades estruturais relevantes envolvem apenas as posições relativas lineares entre nodos:

n = 0 : lista vazia, apresenta zero nodos n > 0 : x₁ é o primeiro nodo

x_n é o último nodo

1 < k < n : x_k é precedido por x_k-1 e sucedido por x_k+1

• Lista linear : sequência de 0 ou mais nodos do mesmo tipo

Definição formal

•

•

•

•

•

•

•

•

Operações sobre listas lineares

• Criação de uma lista

• Inserção de um nodo

• Exclusão de um nodo

• Acesso a um nodo

• Destruição de uma lista

• Contiguidade física

• Encadeamento

Representação física das relações existentes entre os nodosrelações existentes entre os nodos

Listas lineares

Implementação de LL através de contiguidade física

ordem entre os nodos

• Endereços fisicamente adjacentes nodos

L

2

L

1

L

3

L

4

L

5

L

6

L

L

L

L

L

L

1 2 3 4 5 6

L L

Características

 todos os elementos do arranjo tem tipo igual  cada elemento do arranjo é um nodo

 tipo do nodo = tipo do elemento do arranjo  posição no arranjo representa posição na LL  acesso direto aos nodos

 natureza dinâmica – inserção / remoção de nodos  comprimento varia durante aplicação

L2

L1 L3 L4 L5 L6

L1 L2 L3 L4 L5 L6

1 2 3 4 5 6 L L

TipoNodo = registro Nome: string Código: inteiro Valor: real fim registro

TipoLista = arranjo [1 .. N] de TipoNodo

Tipos de dados

Tipos de dados utilizados nos algoritmos para LL implementada com contiguidade física:

1 2 3 4 6 7 9 10 LL IL IL FLFL IA IA FAFA L1 L2 L3 L4 L5 5 8 Lista

Início e final da LL geralmente são diferentes do início e final do arranjo

Início e final da LL

LL Início do Arranjo Final do Arranjo Lista

Início e final da LL geralmente são diferentes do início e final do arranjo

Início e final da LL

Variáveis para identificar Início e Final da Lista

1 2 3 4 6 7 9 10

IL FL

IA FA

L1 L2 L3 L4 L5

Um mesmo arranjo pode ser utilizado para mais de uma lista linear

Mais de uma LL em um arranjo

1 2 3 4 6 7 9 10 LL IL1 FL2 IA FA L1 L2 L1 L2 L3 5 8 IL2 FL1 Lista 1 _{Lista 2}

• criação da lista

• inserção de um novo nodo

• remoção de um nodo

• acesso a um nodo

Operações sobre listas lineares em

contiguidade física

Criação de uma LL vazia

• Inicializar variáveis que guardam início e final da

lista 1 2 3 4 6 7 9 10 LL 5 8 Lista vazia IL = FL = IA-1 IA FA

Algoritmo:

Inicializar LL sobre Arranjo vazia

Algoritmo 3.1 - InicializarLLArr

Entradas: IA (inteiro) Saídas: IL, FL (inteiro)

início

IL  FL  IA - 1 fim

Ex:

Ex: Lista de informações de produtos de uma empresa

TipoNodo = registro

Nome: string Código: inteiro Preço: real

fim registro

TipoLista = arranjo [1 .. 10] de TipoNodo

1 2 3 4 6 7 9 10

LL

5 8

IA FA

Nome Código Preço

IL FL

Inserção de um novo nodo

Informar:

• posição (ordem) do novo nodo na LL

• valor do campo de informação do novo

nodo

Quando não é possível realizar a inserção:

Quando não é possível realizar a inserção:

• posição solicitada fora dos limites da LL existente

• espaço disponível para a LL no arranjo todo preenchido

L1 L2 L3 L4 L5 L6

0 1 2 3 4 5 6 7 L L

16 17 18 19 20 13 14 15 11 12 21 22 23

A

No início

A

No final

A

No meio

Inserção como primeiro nodo da LL

Inserção como primeiro nodo da LL

Inserir

no início

LL inicia no início do arranjo

1 2 3 4 6 7 9 10 LL IL FL IA FA L1 L2 L3 L4 L5 L6 5 8 1 2 3 4 6 7 9 10 LL 5 8 IA FA

Inserção como primeiro nodo da LL

LL inicia no início do arranjo

1 2 3 4 6 7 9 10 LL IL FL IA FA L1 L2 L3 L4 L5 L6 5 8 1 2 3 4 6 7 9 10 LL L1 L2 L3 L4 L5 _L6 L7 5 8 IL FL IA FA Inserir no início Novo nodo

Inserção como primeiro nodo da LL

LL não inicia no início do arranjo

1 2 3 4 6 7 9 10

LL

Inserção como primeiro nodo da LL

LL não inicia no início do arranjo

LL LL 1 2 IL3 4 6 7 FL 9 10 IA FA L1 L2 L3 L4 L5 L6 5 8 1 IL2 3 4 6 7 FL 9 10 IA FA L1 L2 L3 L4 L5 L6 L7 5 8 Inserir no início Novo nodo

Algoritmo 3.2 - InserirIniLLArr Entradas: LL (TipoLista)

IA, FA, IL, FL (inteiro) InfoNodo (TipoNodo)

Saídas: LL (TipoLista)

IL, FL (inteiro) Sucesso (lógico)

Variável auxiliar: Ind (inteiro)

início

se (IA = IL) e (FA = FL) então Sucesso  falso

senão início se IL = 0

então IL  FL  IA senão se IL > IA

então IL  IL-1

senão início {DESLOCAR NODOS PARA CIMA}

para Ind de FL incr -1 até IL faça LL[Ind+1]  LL[Ind] FL  FL+1 fim LL[IL]  InfoNodo Sucesso  verdadeiro fim fim

Algoritmo:

Inserção como último nodo da LL

LL não termina no final do arranjo

1 2 3 4 6 7 9 10

LL

Inserção como último nodo da LL

LL não termina no final do arranjo

1 2 3 4 6 7 9 10

LL

Inserção como último nodo da LL

LL termina no final do arranjo

1 2 3 4 6 7 9 10 LL IL FL IA FA L1 L2 L3 L4 L5 L6 5 8 Inserir no final

Inserção como último nodo da LL

LL termina no final do arranjo

1 2 3 4 6 7 9 10 LL _{L1 L2 L3 L4 L5 L6} 5 8 1 2 3 4 6 7 9 10 LL _{L1 L2 L3 L4 L5 L6 L7} 5 8 IL IA FLFA Inserir no final IL FL IA FA Novo nodo

Algoritmo 3.3 - InserirFimLLArr Entradas: LL (TipoLista)

IA, FA, IL, FL (inteiro) InfoNodo (TipoNodo)

Saídas: LL (TipoLista)

IL, FL (inteiro) Sucesso (lógico)

Variável auxiliar: Ind (inteiro)

início

se (IA = IL) e (FA = FL) então Sucesso  falso

senão início se IL = 0 {LISTA VAZIA}

então IL  FL  IA

senão se FL < FA {TEM ESPAÇO ATRÁS}

então FL  FL+1

senão início {DESLOCAR NODOS PARA BAIXO}

para Ind de IL incr 1 até FL faça LL[Ind-1]  LL[Ind] IL  IL-1 fim LL[FL]  InfoNodo Sucesso  verdadeiro fim fim

Algoritmo:

Algoritmo:

Inserção no meio de LL

Inserção no meio de LL

Algoritmo:

Algoritmo:

Inserir em LL implementada sobre Arranjo na Posição K

• K = 1 → no início da LL

• K = FL – IL + 2 → no final da lista

Caso haja deslocamento

• para cima, caso haja espaço • senão, para baixo

Sucesso retorna falso quando

• não existe espaço no arranjo para a

inserção

Algoritmo:

Algoritmo:

Inserir em LL implementada sobre Arranjo na Posição K

Algoritmo 3.4 - InserirLLArrPosK Entradas: LL (TipoLista)

IA, FA, IL, FL (inteiro)

K (inteiro)

InfoNodo (TipoNodo) Saídas: LL (TipoLista)

IL, FL (inteiro) Sucesso (lógico)

Variável auxiliar: Ind (inteiro)

início

se (IA=IL e FA=FL) ou (K > FL-IL+2) ou (K0) ou (IL=0 e K1) então Sucesso  falso

senão início se IL = 0

então IL  FL  IA senão se FL  FA

então início {DESLOCAR NODOS PARA CIMA}

para Ind de FL incr -1 até IL+K-1 faça LL[Ind+1]  LL[Ind]

FL  FL+1 fim

senão início {DESLOCAR NODOS PARA BAIXO}

para Ind de IL incr 1 até IL+K-2 faça LL[Ind-1]  LL[Ind] IL  IL - 1 fim LL[IL+K-1]  InfoNodo Sucesso  verdadeiro fim

Otimizar:

deslocar nodos da metade para o fim se a inserção for na primeira metade

da lista, e da metade para o início se for na segunda metade

→ desde que haja espaço no lado considerado

40 20 90 80 70 0 1 2 3 4 5 6 7 Início Fim 8 9 K ≤ 3 K > 3

Algoritmo:

Algoritmo:

Algoritmo 3.5 - InserirLLArrPosKOt Entradas: LL (TipoLista)

IA, FA, IL, FL (inteiro) K (inteiro)

InfoNodo (TipoNodo) Saídas: LL (TipoLista)

IL, FL (inteiro) Sucesso (lógico)

Variável auxiliar: Ind (inteiro)

início

se (IA=IL e FA=FL) ou (K > FL-IL+2) ou (K0) ou (IL=0 e K1) então Sucesso  falso

senão início se IL = 0

então IL  FL  (FA-IA+1) div 2 {INSERE NO MEIO}

senão se IL = IA ou ((FL  FA) e (K > (FL-IL+2/2)) então início {DESLOCAMENTO PARA CIMA}

para Ind de FL incr -1 até IL+K-1 faça LL[Ind+1]  LL[Ind]

FL  FL+1 fim

senão início {DESLOCAMENTO PARA BAIXO}

para Ind de IL incr 1 até IL+K-2 faça LL[Ind-1]  LL[Ind] IL  IL - 1 fim LL[IL+K-1]  InfoNodo Sucesso  verdadeiro fim

Algoritmo

Algoritmo

otimizado

otimizado

:

:

Remoção de um nodo

Remoção de um nodo

LL

LL

Algoritmo 3.6 -

RemoverKLLArr

Variável auxiliar: Ind (inteiro)

início

se (K  0) ou (K > FL-IL+1) então Sucesso  falso

senão início

para Ind de IL+K-1 incr 1 até FL-1 faça LL[Ind]  LL[Ind+1] FL  FL-1 se FL = IL–1 então IL  FL  0 Sucesso  verdadeiro fim fim

Deslocar nodos da metade para baixo se o nodo a ser removido estiver na

primeira metade da lista, e da metade para cima se estiver na segunda metade



Otimização da remoção de um nodo

Remover K=2 40 20 90 80 70 23 1 2 3 4 5 6 7 8 9 10 K  3 K > 3 70 20 90 80 23 1 2 3 4 5 6 7 8 9 10 IL IL FL FL

Acessar para Consulta a informações do nodo

Alteração de algum campo de informação do nodo

Acesso a um nodo

O nodo a ser acessado pode ser identificado por

• sua ordem na lista Ex: 2º nodo

• através de seu conteúdo Ex: nodo de conteúdo “D”

1 2 3 4 6 7 9 10 LL IL FL IA FA L1 L2 L3 L4 L5 5 8 1 2 3 4 6 7 9 10 LL IL FL IA FA A B C D E 5 8

Algoritmo 3.7 - AcessarKLLArr Entradas: LL (TipoLista) IL, FL (inteiro) K (inteiro)

Saídas: InfoNodo (TipoNodo)

Sucesso (lógico) início

se (K  0) ou (K > FL-IL+1) ou (IL = 0) então Sucesso  falso

senão início InfoNodo  LL[IL+K-1] Sucesso  verdadeiro fim fim

Algoritmo:

Algoritmo:

Algoritmo 3.8 - PosValLLArr Entradas: LL (TipoLista) IL, FL (inteiro) ValBuscado (TipoValor) Saída: Posição(inteiro) Variáveis auxiliares: I (inteiro) Achou (lógico) início Achou  falso Posição  0 I  IL

enquanto (I  FL) e (não Achou) faça se LL[I].Valor = ValBuscado então início Posição  I Achou  verdadeiro fim senão I  I+1 fim TipoNodo = registro Valor: inteiro Info: TipoInfo fim registro

Algoritmo:

Algoritmo:

Algoritmo 3.9 -

PosValLLArrOrd

Meio, Inf, Sup (inteiro) Achou (lógico) início Achou  falso Posição  0 Inf  IL Sup  FL

enquanto (Inf  Sup) e (não Achou) faça início

Meio  (Inf+Sup) div 2 {DIVISÃO INTEIRA}

se LL[Meio].Valor = ValBuscado então início

Posição  Meio

Achou  verdadeiro fim

senão se LL[Meio].Valor < ValBuscado

então Inf  Meio+1 {BUSCA SEGUE SÓ NA METADE SUPERIOR}

senão Sup  Meio–1 {BUSCA SEGUE SÓ NA METADE INFERIOR}

fim fim

Listas lineares

Descritor contém diversas informações sobre a lista linear :

• localização da lista no arranjo (índices)

• acesso – índice de alguns nodos

• estrutura da lista, como número de nodos

• conteúdo • ...

Descritor de uma LL

1 2 3 4 6 7 9

₁₀

Nodo com menor valor

Nodo com maior valor

DescrLL

TipoNodo = registro

Valor: inteiro Info: TipoInfo fim registro

• Sempre através das informações contidas no descritor

LL[DescrLL [1]].Info – informação contida no primeiro nodo da lista LL[DescrLL [2]].Valor – Valor contido no último nodo da lista

LL[DescrLL [5]].Valor – maior Valor contido na lista

DescrLL [3] – comprimento da lista. A informação está contida diretamente no descritor,

não sendo necessário percorrer a lista para obter seu comprimento 2 1 4 5 3 8 6 7 4 3 Comprimento da lista Último nodo Primeiro nodo

Nodo com menor valor

Nodo com maior valor

DescrLL TipoDescritor =

arranjo [1..5] de inteiros

Acesso a LL com descritor

TipoNodo = registro

Valor: inteiro Info: TipoInfo fim registro

LL[DL.IL].Info – informação contida no primeiro nodo da lista; LL[DL.FL].Valor – valor contido no último nodo da lista;

DL.MaiorValor – maior valor contido no campo Valor de todos os nodos da lista.

TipoDescritor = registro IL: inteiro FL: inteiro MaiorValor: inteiro fim registro Ex 2: FL IL 3 8 4 MaiorValor

Índice do maior valor da lista Final da lista Início da lista DescrLL 6 7 8 9 10 3 4 5 1 2 11 12 13 4 2 5 1 7 9

Descritor utilizado nos algoritmos

Descritor informando espaço disponível para

a lista no arranjo

Duas LL implementadas sobre o mesmo arranjo,

com descritores

• Inicializar lista

• Inserir nodo (início / meio / final)

• Remover nodo (início / meio / final)

• Localizar determinado nodo

Algoritmos para operações em LL com descritores -

contiguidade física

Criação de LL vazia com descritor

Algoritmo:

Algoritmo:

Inicializar LL sobre Arranjo com Descritor

Algoritmo 3.10 - InicLLArrDescr

Entradas: DL (TipoDescr)

IniArea, FimArea (inteiro) Saída: DL (TipoDescr) início DL.IL  0 DL.FL  0 DL.N  0 DL.IA  IniArea DL.FA  FimArea fim

Inserir novo nodo LL com descritor –

contiguidade física

Inserção no início da lista

Inserção no início com deslocamento

Inserção no final da lista

Inserção no final com deslocamento

Inserção no meio da lista

Algoritmo 3.11 - InserirLLArrDesc

Entradas: LL (TipoLista) Saídas: LL (TipoLista) DL (TipoDescr) DL (TipoDescr)

Pos (inteiro) Info (TipoNodo) Variáveis auxiliares: Sucesso (lógico) K (inteiro)

IndPos (inteiro) início

se (DL.N = DL.FA-DL.IA+1) ou (Pos > DL.N+1) ou (Pos < 1) então Sucesso  falso

senão início

Sucesso  verdadeiro DL.N  DL.N + 1

se Pos = 1 {INSERIR NO INÍCIO}

então início se DL.N = 1 então início

DL.IL  (DL.FA-DL.IA+1) div 2 DL.FL  DL.IL

fim

senão se DL.IL > DL.IA

então DL.IL  DL.IL-1 senão início

para K de DL.FL até DL.IL incr-1 faça LL[K+1]  LL[K]

DL.FL  DL.FL+1 fim

LL[DL.IL]  Info fim

senão se Pos = DL.N {INSERIR COMO ÚLTIMO}

então início

se DL.FL < DL.FA

então DL.FL  DL.FL+1 senão início

para K de DL.IL até DL.FL faça LL[K-1]  LL[K]

DL.IL  DL.IL-1 fim

LL[DL.FL]  Info fim

senão início {INSERIR NO MEIO}

se DL.FL < DL.FA então início

IndPos  DL.IL+Pos-1

para K de DL.FL até IndPos incr-1 faça LL[K+1]  LL[K]

DL.FL  DL.FL+1 fim

senão início

IndPos  DL.IL+Pos-2

para K de DL.IL até IndPos faça LL[K-1]  LL[K] DL.IL  DL.IL–1 fim LL[IndPos]  Info fim

Algoritmo (cont):

Remoção de um nodo

Inserção do início da LL

Remoção do final da lista

Remoção no meio da lista

Remoção resultando em LL vazia

Algoritmo:

Algoritmo:

Remover k-ésimo nodo de LL sobre Arranjo com Descritor

Algoritmo 3.12 -

RemoverKLLArrDesc

Variável auxiliar: Ind (inteiro)

início

se (K  0) ou (K > DL.N) então Sucesso  falso senão início

Sucesso  verdadeiro

para Ind de DL.IL+K-1 até DL.FL-1 faça LL[Ind]  LL[Ind+1] DL.FL  DL.FL-1 DL.N  DL.N-1 se DL.FL = DL.IL–1 então DL.IL  DL.FL  0 fim fim

Acesso a um nodo da lista

Nodo identificado por:

• sua posição na lista – k-ésimo nodo • campo de informação

Algoritmo:

Algoritmo:

Acessar k-ésimo nodo de LL sobre Arranjo com Descritor

Algoritmo 3.13 - AcessarKLLArrDesc

Entradas: LL (TipoLista) DL (TipoDescr)

K (inteiro)

Saídas: InfoNodo (TipoNodo)

Sucesso (lógico) início

se (K  0) ou (K > DL.FL-DL.IL+1) ou (DL.N = 0) então Sucesso  falso

senão início

InfoNodo  LL[DL.IL+K-1] Sucesso  verdadeiro

fim fim

Informar Posição do nodo com determinado Valor

em LL sobre Arranjo com Descritor

Algoritmo 3.14 - PosValLLArrDesc

Entradas: LL (TipoLista) DL (TipoDescr)

ValBuscado (TipoValor)

Saída: Posição (inteiro) Variáveis auxiliares: I (inteiro) Achou (lógico) início Achou  falso Posição  0 I  DL.IL

enquanto (I  DL.FL) e (não Achou) faça se LL[I].Valor = Val

então início Posição  I Achou  verdadeiro fim senão I  I+1 fim

Listas lineares

1 2 3 4 6 7 9 10 LL IL FL IA FA L3 L4 L5 L6 L1 L2 5 8 Início da LL Final da LL

• Inicializar lista

• Inserir nodo (início / meio / final)

• Remover nodo (início / meio / final)

• Localizar determinado nodo

Operações

Igual a quando não é feita a ocupação circular do arranjo

Inserção de um novo nodo

Inserção de um novo nodo

No

me

io

Entradas: LL (TipoLista) Saídas: LL (TipoLista) IA, FA, IL, FL (inteiro) IL, FL (inteiro)

K (inteiro) Sucesso (lógico) InfoNodo (TipoNodo)

Variáveis auxiliares: Ind, N, Pos (inteiro)

início

se IL = 0 {LISTA VAZIA}

então N  0

senão se IL  FL

então N  FL-IL+1

senão N  (FA-IL+1) + (FL-IA+1)

se (N = FA-IA+1) ou (K > N+1) ou (K < 1) ou (N=0 e K1) então Sucesso  falso

senão início

se (N = 0)

então início {PRIMEIRO NODO}

Pos  IA

IL  FL  IA fim

senão início

se (IL+K-1  FA) então Pos  IL+K-1

senão Pos  (IA-1) + (K - (FA-IL+1)) se K = 1 {INSERÇÃO NO INÍCIO} então se IL > IA então início Pos  IL-1 IL  IL-1 fim senão início IL  FA Pos  FA

senão se K = N+1 {INSERÇÃO NO FINAL}

então se Pos = FL+1

então FL  FL+1 senão FL  IA senão {INSERÇÃO NO MEIO}

se (IL  FL) e (FL < FA)

ou (IL > FL) e (Pos < IL) então início

para Ind de FL incr-1 até Pos faça LL[Ind+1]  LL[Ind]

FL  FL+1 fim

senão início se FL  FA

então para Ind de FL incr-1 até IA faça LL[Ind+1]  LL[Ind]

LL[IA]  LL[FA]

para Ind de FA-1 incr-1 até Pos faça LL[Ind+1]  LL[Ind] se FL = FA então FL  IA senão FL  FL+1 fim fim LL[Pos]  InfoNodo Sucesso  verdadeiro

Algoritmo (cont):

Remoção de um nodo

Remoção de um nodo

Algoritmo 3.16 -

RemoverKLLCirArr

Entradas: LL (TipoLista)

IA, FA, IL, FL (inteiro)

K (inteiro)

InfoNodo (TipoNodo)

Saídas: LL (TipoLista) IL, FL (inteiro)

Sucesso (lógico)

Variáveis auxiliares: Ind, N, Pos (inteiro)

início

se IL = 0 {LISTA VAZIA}

então N  0

senão se IL  FL

então N  FL-IL+1

senão N  (FA-IL+1) + (FL-IA+1) se (N = 0) ou (K  0) ou (K > N)

então Sucesso  falso senão início

se N = 1 {REMOÇÃO DO ÚNICO}

então IL  FL  0

senão se K = 1 {REMOÇÃO DO PRIMEIRO}

então se IL < FA

então IL  IL+1 senão IL  IA

Algoritmo (cont):

Algoritmo (cont): Remover nodo Posição K da LL Circular sobre Arranjo

senão se K = N {REMOÇÃO DO ÚLTIMO}

então se FL = IA

então FL  FA senão FL  FL-1

senão início {REMOÇÃO NO MEIO}

se (IL+K-1  FA) então Pos  IL+K-1

senão Pos  IA + (K - (FA-IL+1)-1)

se (IL < FL) ou ((IL>FL) e (K>=FA-IL+2)) então início

para Ind de Pos até FL-1

faça LL[Ind]  LL[Ind+1] FL  FL-1

fim

senão início

para Ind de Pos+1 até FA

faça LL[Ind-1]  LL[Ind] LL[FA]  LL[IA]

se FL  IA

então para Ind de IA+1 até FL

faça LL[Ind-1]  LL[Ind] se FL = IA então FL  FA senão FL  FL-1 fim fim Sucesso  verdadeiro fim

Acesso a um novo nodo

•

Algoritmo:

Algoritmo: Acessar k-ésimo nodo da LL Circular sobre Arranjo

Algoritmo 3.17 - AcessarKLLCirArr

Entradas: LL (TipoLista)

IA, FA, IL, FL (inteiro)

K (inteiro)

Saídas: InfoNodo (TipoNodo)

Sucesso (lógico)

Variáveis auxiliares: N, Pos (inteiro)

início

se IL = 0 {LISTA VAZIA}

então N  0

senão se IL  FL

então N  FL-IL+1

senão N  (FA-IL+1) + (FL-IA+1) se (N = 0) ou (K  0) ou (K > N)

então Sucesso  falso senão início

se (IL+K-1  FA) então Pos  IL+K-1

senão Pos  IA + (K - (FA-IL+1)-1) InfoNodo  LL[Pos]

Sucesso  verdadeiro fim

Entradas: LL (TipoLista) Saída: Posição (inteiro) IA, FA, IL, FL (inteiro) Variáveis auxiliares: ValBuscado (TipoValor) N, I (inteiro)

Achou, Sair (lógico) início Achou  falso Posição  0 se IL = 0 {LISTA VAZIA} então N  0 senão se IL  FL então N  FL-IL+1

senão N  (FA-IL+1) + (FL-IA+1) se N  0

então início I  IL

Sair  falso

enquanto (não Achou) e (não Sair) faça se LL[I].Valor = Val

então início

Posição  I

Achou  verdadeiro fim

senão se I = FL

então Sair  verdadeiro senão se I  FA

então I  I+1 senão I  IA fim fim

Listas lineares

• Ordem dos nodos da lista definida por informação contida

em cada nodo

• Ordem independe da posição física dos nodos

• Contiguidade lógica dos nodos na LL

Campo de elo

• contido em cada nodo

• informa qual o próximo nodo da lista

Requisitos para LL encadeada

• Encadeamento entre os nodos através de campo de elo

• Indicação de final de lista

L1 L2 L3 L4

PtLista

Li

Info Elo

Operações básicas

• Criar e inicializar uma lista

• Inserir novo nodo

• Remover um nodo

• Acessar um nodo

• Destruir lista

Algoritmos

Algoritmos

Tipos de dados utilizados nos algoritmos:

TipoPtNodo = TipoNodo TipoNodo = registro

Info: TipoInfoNodo Elo : TipoPtNodo fim registro

Criação de LL encadeada

• Inicializar apontador do início da lista em endereço nulo

• Lista inicialmente vazia

L1 L2 L3 L4 PtLista

PtLista

Algoritmo:

Algoritmo: Inicializar LL Encadeada

Algoritmo 3.19 - InicializarLLEnc

Entradas:

Saída: PtLista (TipoPtNodo)

início

PtLista  nulo fim

Inserção de um novo nodo

Inserção de um novo nodo

• Preencher com valor

• Encadear na posição solicitada

• No início da lista (primeiro nodo)

• No final da lista (último nodo)

Inserção no início de LL encadeada

Algoritmo 3.20 - InserirIniLLEnc Entradas: PtLista (TipoPtNodo) Dados (TipoInfoNodo) Saídas: PtLista (TipoPtNodo) Sucesso (lógico)

Variável auxiliar: Pt (TipoPtNodo)

início

alocar(Pt)

se Pt = nulo

então Sucesso  falso senão início Sucesso  verdadeiro Pt.Info  Dados Pt.Elo  PtLista PtLista  Pt fim fim

Algoritmo:

Inserção no final de LL encadeada

Algoritmo 3.21 - InserirFimLLEnc Entradas: PtLista (TipoPtNodo) Dados (TipoInfoNodo) Saídas: PtLista (TipoPtNodo) Sucesso (lógico)

Variáveis auxiliares: P1, P2 (TipoPtNodo)

início

alocar(P1) se P1 = nulo

então Sucesso  falso senão início Sucesso  verdadeiro P1.Info  Dados P1.Elo  nulo se PtLista = nulo então PtLista  P1 senão início P2  PtLista

enquanto P2.Elo  nulo faça P2  P2.Elo P2.Elo  P1 fim fim fim

Algoritmo:

Inserção no meio de LL encadeada

Percorrer a lista a partir do primeiro nodo até a posição de inserção

Algoritmo 3.22 - InserirKLLEnc Entradas: PtLista (TipoPtNodo) K (inteiro)

Dados (TipoInfoNodo) Saídas: PtLista (TipoPtNodo)

Sucesso (lógico)

Variáveis auxiliares: PAnt, PtNovo (TipoPtNodo)

início

alocar(PtNovo) se PtNovo = nulo

então Sucesso  falso

senão se ((PtLista = nulo) e (K  1)) ou (K < 1) então início liberar(PtNovo) Sucesso  falso fim senão se K = 1 então início PtNovo.Info  Dados PtNovo.Elo  PtLista PtLista  PtNovo Sucesso  verdadeiro fim

Algoritmo:

senão início

PtAnt  PtLista

enquanto (PtAnt.Elo  nulo) e (K > 2) faça início PtAnt  PtAnt.Elo K  K - 1 fim se K > 2 então início liberar(PtNovo) Sucesso  falso fim senão início PtNovo.Info  Dados PtNovo.Elo  PtAnt.Elo PtAnt.Elo  PtNovo Sucesso  verdadeiro fim fim fim

Remoção de um nodo

• Localizar o nodo a ser removido

• Atualizar encadeamento da lista

• Liberar espaço ocupado pelo nodo

• Se for o último nodo da lista → lista fica vazia

Remoção de um nodo

L1 L2 L3 L4

PtLista

L1 L2 L3

PtLista

Algoritmo 3.23 - RemoverKLLEnc Entradas: PtLista (TipoPtNodo) K (inteiro)

Saídas: PtLista (TipoPtNodo) Sucesso (lógico)

Variáveis auxiliares: PtAnt, PtK (TipoPtNodo)

início

se K < 1

então Sucesso  falso senão início PtK  PtLista PtAnt  nulo enquanto (PtK  nulo) e (K > 1) faça início K  K-1 PtAnt  PtK PtK  PtK.Elo fim se PtK = nulo

então Sucesso  falso senão início

se PtK = PtLista

então PtLista  PtLista.Elo senão PtAnt.Elo  PtK.Elo liberar(PtK)

Sucesso  verdadeiro fim fim fim

Algoritmo:

Acesso a um nodo

• Nodos não podem ser acessados diretamente

• Percorrer a lista até encontrar o nodo buscado

• Nodo identificado por

• sua posição na lista • conteúdo

L1 L2 L3 L4 PtLista

Algoritmo:

Algoritmo: Acessar K-ésimo nodo de LL Encadeada

Algoritmo 3.24 - AcessarKLLEnc

Entradas: PtLista (TipoPtNodo) K (inteiro) Saída: PtK (TipoPtNodo) início se (K < 1) ou (PtLista = nulo) então PtK  nulo senão início PtK  PtLista enquanto (PtK  nulo) e (K > 1) faça início K  K-1 PtK  PtK.Elo fim se K > 1 então PtK  nulo fim fim

Destruir lista

• Percorrer lista a partir do primeiro nodo

• Liberar todos os nodos da lista

Algoritmo:

Algoritmo: Destruir LL Encadeada

Algoritmo 3.25 - DestruirLLEnc

Entrada: PtLista (TipoPtNodo) Saída: PtLista (TipoPtNodo)

Variável auxiliar: Pt (TipoPtNodo)

begin

enquanto PtLista  nulo faça início Pt  PtLista PtLista  PtLista.Elo liberar(Pt) fim liberar(PtLista) fim

LL encadeada circular

• Elo do último nodo indica endereço do primeiro

• Lista pode ser percorrida a partir de qualquer nodo

• Lista com 1 só nodo: elo do nodo aponta para ele

mesmo

L1 L2 L3 L4

PtLista

PtLista

Operações básicas

• Inserir novo nodo

• Remover um nodo

• Acessar um nodo

• Destruir lista

Algoritmos

Algoritmos

Inserção de um novo nodo

• Alocar o novo nodo

• Preencher com valor

• Encadear adequadamente L1 L2 L3 L4 PtLista L1 L2 L3 L4 PtLista L5

Algoritmo 3.26 - InserirKLLEncCir Entradas: PtLista (TipoPtNodo) K (inteiro)

Dados (TipoInfoNodo) Saídas: PtLista (TipoPtNodo) Sucesso (lógico)

Variáveis auxiliares: PtAnt, PtNovo (TipoPtNodo)

início

alocar(PtNovo) se PtNovo = nulo

então Sucesso  falso

senão se ((PtLista = nulo) e (K  1)) ou (K < 1) então início liberar(PtNovo) Sucesso  falso fim senão início Sucesso  verdadeiro PtNovo.Info  Dados

se K = 1 {INSERE COMO PRMEIRO} { então início SEGUE }

Algoritmo:

Algoritmo:

então início

se PtLista = nulo

então PtNovo.Elo  PtNovo senão início

PtAnt  PtLista

enquanto PtAnt.Elo  PtLista faça PtAnt  PtAnt.Elo

PtNovo.Elo  PtLista PtAnt.Elo  PtNovo fim PtLista  PtNovo fim senão início PtAnt  PtLista

enquanto (PtAnt.Elo  PtLista) e (K > 2) faça início

PtAnt  PtAnt.Elo K  K - 1

fim

se K > 2 {ORDEM FORA DA LISTA}

então início

liberar(PtNovo) Sucesso  falso fim

senão início

PtNovo.Info  Dados {INSERE NO MEIO}

PtNovo.Elo  PtAnt.Elo PtAnt.Elo  PtNovo

fim fim fim fim

Algoritmo (cont):

Remoção de um nodo

• Localizar posição do nodo

• Adequar encadeamentos

Algoritmo 3.27 - RemoverKLLEncCir

Entradas: PtLista (TipoPtNodo) K (inteiro)

Saídas: PtLista (TipoPtNodo) Sucesso (lógico)

Variáveis auxiliares: PtAnt, PtK (TipoPtNodo)

início

se (K < 1) ou (PtLista = nulo) então Sucesso  falso

senão início

Sucesso  verdadeiro se K = 1

então se PtLista.Elo = PtLista então início liberar(PtLista) PtLista  nulo fim senão início PtAnt  PtLista

enquanto PtAnt.Elo  PtLista faça PtAnt  PtAnt.Elo

PtAnt.Elo  PtLista.Elo liberar(PtLista)

PtLista  PtAnt.Elo fim

{ senão início SEGUE }

Algoritmo:

senão início

PtAnt  PtLista

enquanto (PtAnt.Elo  PtLista) e (K > 2) faça início

PtAnt  PtAnt.Elo K  K - 1

fim

se PtAnt.Elo = PtLista {ORDEM FORA DA LISTA}

então Sucesso  falso senão início PtK  PtAnt.Elo PtAnt.Elo  PtK.Elo liberar(PtK) fim fim fim fim

Acesso à lista

• Iniciar sempre acessando primeiro nodo da lista

• Seguir acessando de acordo com campos de elo

• Para quando encontrar novamente o primeiro nodo da lista

L1 L2 L3 L4

PtLista

L5

A seguir: algoritmo que acessa todos os nodos de uma LL encadeada circular, imprimindo o campo de informação de todos os nodos acessados

Algoritmo 3.28 - ImprimirLLEncCir Entrada: PtLista (TipoPtNodo) Saídas:

Variável auxiliar: PtAux (TipoPtNodo)

início

se PtLista = nulo

então escrever(´Lista vazia!´) senão início

PtAux  PtLista repita

escrever(PtAux.Info) PtAux  PtAux.Elo até que PtAux = PtLista fim

fim

Algoritmo:

Algoritmo:

Listas lineares

PtLista

L1 L2 _{L3 L4}

• Cada nodo tem 2 campos de elo

• A lista pode ser percorrida nas duas direções

LL duplamente encadeadas

Anterior

Operações

• Criar e inicializar uma lista

• Inserir novo nodo

• Remover um nodo

• Acessar um nodo

• Destruir lista

Algoritmos

Semelhantes a LL encadeada simples

Tipo de nodo utilizado nos algoritmos:

TipoNodo = registro

Ant: TipoPtNodo Info: TipoInfoNodo Prox: TipoPtNodo