listas (parte 1)

Tecnologia em Sistemas para Internet - IFMS

Aula 04 – Listas (parte 1)

Estruturas de DadosProf.º Msc. Sidney Roberto de Sousa

[email protected]

Tec. em Sistemas para Internet - IFMS 2

O que veremos nesta aula?

● O que é uma lista?● Listas simples● Listas encadeadas● Listas duplamente encadeadas


Lista

● Estrutura de dados abstrata e linear que implementa uma coleção finita e ordenada de valores

● Cada instância de um valor na lista é chamado de ítem (ou elemento) da lista


Propriedades de uma lista

● Tamanho: Número de itens armazenados na lista.● Índice: Cada elemento na lista possui um índice, ou seja, um

número que o identifica.● Tipo(*): Toda lista possui um tipo. Assim, todo item da lista possui

o mesmo tipo.● Igualdade: Uma lista a é igual a uma outra lista b se e somente se,

para cada índice i de a e b, ai é igual a bi quanto aos seus valores e estruturas.

(* Na verdade, tanto na linguagem Java quanto na maioria das linguagens modernas, uma lista pode conter itens de tipos variados. Manteremos esta definição por enquanto apenas por conveniência aos nossos estudos.)


Listas simples

● Listas simples ou listas estáticas são listas que permitem a adição de um número limitado de itens → tamanho invariável

● Neste tipo de lista, o acesso a um item situado em um determinado índice é feito de forma rápida e prática

● Listas simples podem ser implementadas como matrizes unidimensionais (vetores)


Exemplo: Lista simples

Classe ListaSimples

(abaixo no blog)


Inserção em uma lista simples

public boolean adicionarItem(Integer novoItem, int indiceDoItem) {

if (indiceDoItem >= 0 && indiceDoItem < tamanho) { lista[indiceDoItem] = novoItem;

return true;

}

return false;

}





return true;

}

return false;

}

Verifica se a posição desejada para o armazenamento do novo elemento é válida.




if (indiceDoItem >= 0 && indiceDoItem < tamanho) {

lista[indiceDoItem] = novoItem;

return true;

}

return false;

}

Se a posição for válida, o novo elemento é inserido na posição desejada. Caso já haja um outro elemento nesta posição, tal elemento é sobreposto pelo novo elemento. O método retorna o valor true, indicando que o elemento foi inserido com sucesso.





return true;

}

return false;

}

Se a posição for inválida, o método retorna o valor false, indicando que o elemento não foi inserido.


Remoção em uma lista simples

public Integer removerItem(Integer indiceDoItem) {

if (indiceDoItem >= 0 && indiceDoItem < tamanho

&& lista[indiceDoItem] != null) {

Integer itemRemovido = lista[indiceDoItem];

lista[indiceDoItem] = null;

return itemRemovido;

}

return null;

}









}

return null;

}

Verifica se existe algum elemento a ser removido na posição desejada. Também verifica se tal posição é válida.









}

return null;

}

Caso a posição informada seja válida e exista algum elemento a ser removido, o elemento é “removido” ao se substituir o seu valor pelo valor null. Por fim, o método retorna o valor do item recém removido.









}

return null;

}

Caso a posição informada seja inválida ou não exista um elemento a ser removido, o método retorna o valor null.


Pegando um elemento de uma lista simples

public Integer pegarItem(Integer indiceDoItem) {


return lista[indiceDoItem];

}

return null;

}






}

return null;

}

Primeiramente, o método verifica se a posição do item desejado é válida.






}

return null;

}

Se a posição é válida, o elemento desejado é retornado. Note que o acesso ao elemento da lista é realizado diretamente por meio do uso do índice correto. Caso nenhum elemento tenha sido adicionado nesta posição, o valor null é retornado.






}

return null;

}

Se a posição é inválida, o método retorna o valor null.


Utilizando a classe ListaSimples

ListaSimples listaSimples = new ListaSimples(10);

listaSimples.adicionarItem(8, 0);





listaSimples.removerItem(5);

listaSimples.removerItem(2);

for (int i = 0; i < listaSimples.tamanhoDaLista(); i++) {

System.out.print(listaSimples.pegarItem(i) + " ");

}

/*

* Imprime na tela:

* 8 null null null null null 123 null null 98

*/


Listas encadeadas

● Listas encadeadas ou listas ligadas são listas dinâmicas que permitem a adição de um número teoricamente ilimitado de itens

● Neste tipo de lista, o acesso aos itens não é realizado diretamente por meio de um índice

● Cada elemento da lista possui um link para o próximo elemento da lista


Exemplo: Lista encadeada

Classes No e ListaEncadeada

(abaixo no post)


Classe No

public class No {

private Integer item;

private No proximoItem;

public No() {

proximoItem = null;

}

// Getters e setters para os atributos da classe...

}


Classe No

public class No {



public No() {

proximoItem = null;

}


}

Encapsula um item na lista encadeada


Classe No

public class No {



public No() {

proximoItem = null;

}


}

Armazena o valor do item


Classe No

public class No {



public No() {

proximoItem = null;

}


}

Ponteiro (link) para o próximo item da lista encadeada


Classe No

public class No {



public No() {

proximoItem = null;

}


}

Construtor da classe No. Inicializa o atributo proximoItem com o valor null. Isto indica que inicialmente o item não estão ligado a um próximo item.


Representação da lista encadeada

item

pro

xim

oIt

em

item

pro

xim

oIt

em

item

pro

xim

oIt

em

item

pro

xim

oIt

em

No No No No


Classe ListaEncadeada

public class ListaEncadeada {

private int tamanho;

private No primeiroItem;

private No ultimoItem;

public ListaEncadeada() {

primeiroItem = null;

ultimoItem = null;

tamanho = 0;

}

// Restante da classe...

}









ultimoItem = null;

tamanho = 0;

}


}

Encapsula uma lista encadeada, onde cada item da lista é encapsulado pela classe No. Contém as operações sobre a lista.









ultimoItem = null;

tamanho = 0;

}


}

Guarda o tamanho da lista, ou seja, o número de ítens contidos nela.









ultimoItem = null;

tamanho = 0;

}


}

Guarda o primeiro item da lista.









ultimoItem = null;

tamanho = 0;

}


}

Guarda o último item da lista.









ultimoItem = null;

tamanho = 0;

}


}

Construtor da classe ListaEncadeada. Inicializa os atributos da classe, sinalizando que a lista ainda não possui elementos.


Inserindo um novo item no início

public void adicionarNoInicio(Integer novoItem) {

if (tamanho == 0) {

primeiroItem = new No();

primeiroItem.setItem(novoItem);

ultimoItem = primeiroItem;

} else {

No antigoPrimeiroItem = primeiroItem;



primeiroItem.setProximoItem(antigoPrimeiroItem);

}

tamanho++;

}




if (tamanho == 0) {




} else {





}

tamanho++;

}

Caso a lista esteja vazia, um novo item é criado com o valor desejado. O novo item se torna o primeiro e o último item da lista simultaneamente.




if (tamanho == 0) {




} else {





}

tamanho++;

}

Caso a lista não esteja vazia, um novo item é criado com o valor desejado. O novo item se torna o primeiro item da lista.




if (tamanho == 0) {




} else {





}

tamanho++;

}

Após o item ser inserido, o tamanho da lista é incrementado em uma unidade.


Inserindo um novo item no final

public void adicionarNoFinal(Integer novoItem) {

if (tamanho == 0) {

ultimoItem = new No();

ultimoItem.setItem(novoItem);

primeiroItem = ultimoItem;

} else {

No antigoUltimoItem = ultimoItem;



antigoUltimoItem.setProximoItem(ultimoItem);

}

tamanho++;

}




if (tamanho == 0) {




} else {





}

tamanho++;

}

Caso a lista esteja vazia, um novo item é criado com o valor desejado. O novo item se torna o primeiro e o último item da lista simultaneamente.




if (tamanho == 0) {




} else {





}

tamanho++;

}

Caso a lista não esteja vazia, um novo item é criado com o valor desejado. O novo item se torna o último item da lista.




if (tamanho == 0) {




} else {





}

tamanho++;

}

Após o item ser inserido, o tamanho da lista é incrementado em uma unidade.


Inserindo um novo item em qualquer posiçãopublic boolean adicionarNaPosicao(Integer novoItem, int posicao) {

if (posicao >= 1 && posicao <= tamanho + 1) {

if (posicao == 1) {

adicionarNoInicio(novoItem);

} else if (posicao == tamanho + 1) {

adicionarNoFinal(novoItem);

} else {

No novoNo = new No();

novoNo.setItem(novoItem);

int contador = 1;

No itemAnteriorAoNovo = primeiroItem;

while (contador < posicao 1) {

itemAnteriorAoNovo = itemAnteriorAoNovo.getProximoItem();

contador++;

}

novoNo.setProximoItem(itemAnteriorAoNovo.getProximoItem());

itemAnteriorAoNovo.setProximoItem(novoNo);

tamanho++;

}

return true;

}

return false;

}




if (posicao == 1) {




} else {



int contador = 1;




contador++;

}



tamanho++;

}

return true;

}

return false;

}

Se a posição desejada for válida, então o novo item pode ser inserido.




if (posicao == 1) {




} else {



int contador = 1;




contador++;

}



tamanho++;

}

return true;

}

return false;

}

Se a primeira posição for a desejada, então o método de inserção de itens no início da lista é chamado.




if (posicao == 1) {




} else {



int contador = 1;




contador++;

}



tamanho++;

}

return true;

}

return false;

}

Se a última posição for a desejada, então o método de inserção de itens no final da lista é chamado.




if (posicao == 1) {




} else {



int contador = 1;




contador++;

}



tamanho++;

}

return true;

}

return false;

}

Se a posição desejada não for a primeira nem a última, então o método percorre a lista encadeada até encontrar a posição desejada. Por fim, o item é inserido na posição correta.




if (posicao == 1) {




} else {



int contador = 1;




contador++;

}



tamanho++;

}

return true;

}

return false;

}

Se o item foi inserido com sucesso, o método retorna o valor true indicando o fato.




if (posicao == 1) {




} else {



int contador = 1;




contador++;

}



tamanho++;

}

return true;

}

return false;

}

Caso contrário, a posição desejada era inválida e portanto o item não foi inserido. Assim, o método retorna o valor false indicando tal fato.


Removendo um itempublic boolean remover(int posicao) {

if (tamanho > 0 && posicao >= 1 && posicao <= tamanho) {

No item = primeiroItem;

No anterior = null;

int contador = 1;

while (contador < posicao) {

anterior = item;

item = item.getProximoItem();

contador++;

}

No proximo = item.getProximoItem();

if (anterior != null) {

anterior.setProximoItem(proximo);

} else {

primeiroItem = proximo;

}

tamanho;

if (tamanho <= 1) {



}

return true;

}

return false;

}





No anterior = null;

int contador = 1;


anterior = item;


contador++;

}




} else {


}

tamanho;

if (tamanho <= 1) {



}

return true;

}

return false;

}

Se a posição é válida, ou seja, existe um item em tal posição, então o item pode ser removido.





No anterior = null;

int contador = 1;


anterior = item;


contador++;

}




} else {


}

tamanho;

if (tamanho <= 1) {



}

return true;

}

return false;

}

O item a ser removido é encontrado.





No anterior = null;

int contador = 1;


anterior = item;


contador++;

}




} else {


}

tamanho;

if (tamanho <= 1) {



}

return true;

}

return false;

}

Se o item a ser removido não for o primeiro, então o seu vizinho anterior é ligado ao seu vizinho posterior.





No anterior = null;

int contador = 1;


anterior = item;


contador++;

}




} else {


}

tamanho;

if (tamanho <= 1) {



}

return true;

}

return false;

}

Se o item a ser removido for o primeiro, então o seu vizinho posterior se torna o novo primeiro item da lista.





No anterior = null;

int contador = 1;


anterior = item;


contador++;

}




} else {


}

tamanho;

if (tamanho <= 1) {



}

return true;

}

return false;

}

Após o item ser removido, o tamanho da lista é decrementado em uma unidade. Se a lista ficou vazia, então os ponteiros do primeiro e último itens apontam para null. Se a lista ficou com apenas um item, então os ponteiros do primeiro e último ítens apontam para o único item da lista. Se o item foi removido com sucesso, o valor true é retornado indicando tal fato.





No anterior = null;

int contador = 1;


anterior = item;


contador++;

}




} else {


}

tamanho;

if (tamanho <= 1) {



}

return true;

}

return false;

}

Se a posição for inválida, então o valor false é retornado indicando tal fato.


Pegando um item da listapublic No pegarItem(int posicao) {



int contador = 1;

while (posicao < contador) {


contador++;

}

return item;

}

return null;

}





int contador = 1;



contador++;

}

return item;

}

return null;

}

Se a posição é válida, ou seja, existe um item em tal posição, então o item pode ser retornado.





int contador = 1;



contador++;

}

return item;

}

return null;

}

A lista encadeada é percorrida até se chegar na posição desejada. Quando a posição é alcançada, então o item correto é retornado.





int contador = 1;



contador++;

}

return item;

}

return null;

}

Se a posição desejada for inválida, então o valor null é retornado.


Utilizando a classe ListaEncadeada

ListaEncadeada listaEncadeada = new ListaEncadeada();

listaEncadeada.adicionarNoInicio(13);



listaEncadeada.adicionarNoFinal(500);

listaEncadeada.adicionarNaPosicao(457, 2);

No item = listaEncadeada.pegarItem(1);

// Imprime na tela:

// 19823 457 78 13 500

while (item != null) {

System.out.print(item.getItem() + " ");


}


Listas duplamente encadeadas

● Similares às listas encadeadas● Porém, cada item possui um ponteiro para os

ítens anterior e posterior a si na lista


Representação da lista duplamente encadeada

item

pro

xim

oIt

em

item

pro

xim

oIt

em

item

pro

xim

oIt

em

item

pro

xim

oIt

em

No No No No

ite

mA

nte

rio

r

item

An

teri

or

ite

mA

nte

rio

r

item

An

teri

or


Exemplo: Lista duplamente encadeada

Classes NoDuplo e ListaDuplamenteEncadeada

(abaixo no post)


Exemplo: Lista duplamente encadeada

Classes NoDuplo e ListaDuplamenteEncadeada

(abaixo no post)?


Exercício

Implemente as classes NoDuplo e ListaDuplamenteEncadeada.


That's not all, folks!

Na próxima aula falaremos mais sobre listas, mas de uma forma mais suave...

listas (parte 1)

Technology