Estruturas de Dados em Java

Listas Ligada Simples

Prof. Jailton Carlos
Jailton.paiva@ifrn.edu.br

25/11/2011 1
 OBJETIVO DA AULA DE HOJE

Compreender e aplicar os conceitos de

Listas Encadeadas e Deques em Java

25/11/2011 2
 Lista Encadeada
• Na aula anterior vimos a TAD pilha e Fila
utilizando arranjo.

• Arranjos são interessantes e simples para

armazenar dados em uma certa ordem, mas
têm o problema de não serem muito
adaptáveis, uma vez que deve-se prever o
tamanho N do arranjo.
Listas Encadeadas e
3
Deques
 Lista Encadeada
• É uma estrutura de dados concreta que consiste em
uma coleção de nós dispostos linearmente
– Simples encadeada: Cada nó conhece a posição do nó
seguinte (next)
– Duplamente encadeada: Cada nó conhece a posição do nó
anterior (prev) e do nó seguinte (next)

A B C D
Listas Encadeadas e
4
Deques
 Aplicações de Listas Encadeadas
• Implementação de diversos TADs:
– Pilhas, Filas, Deques, Vetores, Listas, Seqüências
– Árvores, Grafos
• Vantagens
– A memória alocada é O(n) onde n é o número de
objetos no TAD

Listas Encadeadas e
5
Deques
 Lista Simplesmente Encadeada
• Uma lista simplesmente encadeada e genérica pode
ser implementada por duas classes:

• Uma classe modela cada nó da lista e possui:

– Uma referência para um elemento da classe Object
– Uma referência para o nó seguinte (next)

• A outra classe modela a lista como um todo e

normalmente implementa a interface de um TAD

Listas Encadeadas e
6
Deques
 Classe Node em uma LSE

public class Node<T> {

private T element;
private Node next; Object Object
public Node () { this(null, null); }
public Node (Te, Node n) { element = e; next = n; }
public T getElement () { return element; }
public Node getNext () { return next; };
public void setElement (T newElem) { element = newElem; }
public void setNext (Node newNext) { next = newNext; }
}

Listas Encadeadas e
7
Deques
 Classe LSE
public class LSE {
private Node head; // essencial
private Node tail; // dispensável
:
}
head tail

A B C D
Listas Encadeadas e
8
Deques
 LSE: Inserção no início
• Tempo: O(1) head tail

Node v = new Node();

v.setNext(head);
head = v; v head tail

head tail

Listas Encadeadas e
9
Deques
 LSE: Deleção no início
• Tempo: O(1) head tail

head = head.getNext();

head tail

head tail

Listas Encadeadas e
10
Deques
 LSE: Inserção no fim
• Tempo: O(1) head tail

Node v = new Node();

tail.setNext(v);
tail = v; head tail v

head tail

Listas Encadeadas e
11
Deques
 LSE: Deleção no fim
• Tempo: O(n) head tail

v = head;
while (v.getNext() != tail)
v = v.getNext(); head v tail
tail = v;
tail.setNext(null);

head tail

Listas Encadeadas e
12
Deques
 Implementação de Pilha com LSE
public interface Stack<T> {
public int size();
public boolean isEmpty();
public T top() throws StackEmptyException;
public void push(T element);
public T pop() throws StackEmptyException;
}

• Inserções e Deleções no início da lista

Listas Encadeadas e
13
Deques
 Classe Pilha com LSE
top
class LinkedStack<T> implements Stack<T> {
private Node<T> top;
private int size;
public LinkedStack() { top = null; size = 0; }
public int size() { return size; }
public boolean isEmpty() {
if (top == null) return true;
return false; }
public T top() throws StackEmptyException {
if (isEmpty()) throw new StackEmptyException("stack is empty");
return top.getElement(); }

Listas Encadeadas e
14
Deques
 Classe Pilha com LSE
top2 top1
public void push(T element) {
Node<T> v = new Node<T>();
v.setElement(element);
v.setNext(top);
top = v; size++; }
public T pop() throws StackEmptyException {
if (isEmpty()) throw new StackEmptyException("stack is empty");
T temp = top.getElement();
top = top.getNext(); top1 top2
size--; return temp; }
}

Listas Encadeadas e
15
Deques
 Implementação de Fila com LSE
public interface Queue<T> {
public int size();
public boolean isEmpty();
public T front() throws QueueEmptyException;
public void enqueue(T element);
public T dequeue() throws QueueEmptyException;
}

• Inserções no fim da lista

• Deleções no início da lista

Listas Encadeadas e
16
Deques
 Classe Fila com LSE
head tail
class LinkedQueue<T> implements Queue<T> {
private Node<T> head;
private Node<T> tail;
private int size;
public LinkedQueue() { head = tail = null; size = 0; }
public int size() { return size; }
public boolean isEmpty() {
if (head == null) return true;
return false; }
public T front() throws QueueEmptyException {
if (isEmpty()) throw new QueueEmptyException("queue is empty");
return head.getElement(); }

Listas Encadeadas e
17
Deques
 Classe Fila com LSE
head tail1 tail2
public void enqueue(T element) {
Node<T> v = new Node<T>();
v.setElement(element); v.setNext(null);
if (size()==0) head = v; else tail.setNext(v);
tail = v; size++; }
public T dequeue() throws QueueEmptyException {
if (isEmpty()) throw new QueueEmptyException("queue is empty");
T temp = head.getElement();
head = head.getNext(); size--; head1 head2 tail
if (size()==0) tail = null;
return temp; }

Listas Encadeadas e
18
Deques
 Exercícios
1. Implemente a interface Stack e as classes Node e
LinkedStack em Java. Utilize as classes para criar uma pilha
de inteiros e execute uma seqqência qualquer de operações
sobre a pilha.

2. Implemente a interface Queue e as classe Node e

LinkedQueue em Java. Utilize as classes para criar uma fila
de inteiros e execute uma seqüência qualquer de operações
sobre a fila.

Listas Encadeadas e
19
Deques
 Referência Bibliográfica
• Estrutura de Dados e Algoritmos em Java
– Michael T. Goodrich
– Roberto Tamassia
• www.datastructures.net

Pilhas e Filas 20