Listas simples e encadeadas

Tecnologia em Sistemas para Internet - IFMS
Aula 04 – Listas (parte 1)
Estruturas de Dados
Prof.º Msc. Sidney Roberto de Sousa
sidney.sousa@ifms.edu.br

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.

        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
proximoItem
item
proximoItem
item
proximoItem
item
proximoItem
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ção
public 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 item
public 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;
}

Removendo um item
        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.

Removendo um item
        No anterior = null;
        int contador = 1;
            anterior = item;
            contador++;
        }
        } else {
        }
        tamanho;
        if (tamanho <= 1) {
        }
        return true;
    }
    return false;
}
O item a ser removido é
encontrado.

Removendo um item
        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.

Removendo um item
        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.

Removendo um item
        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.

Removendo um item
        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 lista
public 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
proximoItem
item
proximoItem
item
proximoItem
item
proximoItem
No No No No
itemAnterior
itemAnterior
itemAnterior
itemAnterior

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 simples e encadeadas

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (20)

Semelhante a Listas simples e encadeadas

Semelhante a Listas simples e encadeadas (20)

Mais de Sidney Roberto

Mais de Sidney Roberto (20)

Listas simples e encadeadas