Tutoriais - Programação Orientada a ObjetosImplemente o diagrama de classes apresentado a seguir, que especifica os tipos abstratos de dados fila (Queue) e pilha (Stack) a partir do tipo abstrato de dados deque (Dequeue), que armazena os elementos numa lista simplesmente encadeada de tipos genéricos (generics).
Conforme Goodrich (2007), uma lista simplesmente encadeada é uma coleção de nodos que juntos formam uma ordem linear, no qual cada nodo (Node) é um objeto que armazena uma referência para um elemento e uma referência, chamada next, para o próximo nodo, conforme apresentado na Figura 01. O primeiro nodo de uma lista simplesmente encadeada é normalmente chamada de cabeça (header).
O tipo abstrato de dados deque (Dequeue) é uma estrutura de dados similar a uma fila, mas nos quais os elementos podem ser inseridos e/ou removidos em ambas as extremidades da lista (Goodrich, 2007). Os métodos especificados para o tipo abstrato de dados deque (Dequeue) são:
empty - verificar se o deque está vazio.offerFirst - inserir um novo elemento no início do deque.offerLast - inserir um novo elemento no final do deque.peekFirst - recuperar o primeiro elemento do deque, ou lançar a exceção EmptyDequeueException se o deque estiver vazio.peekLast - recuperar o último elemento do deque, ou lançar a exceção EmptyDequeueException se o deque estiver vazio.pollFirst - recuperar e remover o primeiro elemento do deque, ou lançar a exceção EmptyDequeueException se o deque estiver vazio.pollLast - recuperar e remover o último elemento do deque, ou lançar a exceção EmptyDequeueException se o deque estiver vazio.size - retornar o número de elementos do deque.Conforme Deitel (2003), o tipo abstrato de dados fila (Queue) é semelhante a uma fila de caixa em um supermercado - a primeira pessoa na fila é atendida primeiro e os outros clientes entram na fila apenas no final e esperam ser atendidos. Os nodos da fila são removidos apenas do início (ou cabeça) da fila e são inseridos somente no final (ou cauda) da fila. Por essa razão, trata-se uma fila como uma estrutura de dados primeiro a entrar, primeiro a sair (first-in, first-out - FIFO). Os métodos especificados para o tipo abstrato de dados fila (Queue) são:
empty - verificar se a fila está vazia.offer - inserir um novo elemento no fim da fila.peek - recuperar o elemento no início da fila, ou lançar a exceção EmptyQueueException se a fila estiver vazia.poll - recuperar e remover o elemento no início da fila, ou lançar a exceção EmptyQueueException se a fila estiver vazia.size - retornar o número de elementos da fila.Conforme Deitel (2003), o tipo abstrato de dados pilha (Stack) é uma versão limitada de uma lista simplesmente encadeada - novos nodos podem ser adicionados a uma pilha e removidos de uma pilha apenas na parte superior (topo). Por essa razão, a pilha é conhecida como uma estrutura de dados último a entrar, primeiro a sair (last-in, first-out - LIFO). Os métodos especificados para o tipo abstrato de dados pilha (Stack) são:
empty - verificar se a pilha está vazia.peek - recuperar o elemento no topo da pilha, ou lançar a exceção EmptyStackException se a pilha estiver vazia.pop - recuperar e remover o elemento no topo da pilha, ou lançar a exceção EmptyStackException se a pilha estiver vazia.push - inserir um novo elemento no topo da pilha.size - retornar o número de elementos da pilha.
/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
import java.io.Serializable;
/**
* Nodo de uma lista simplesmente encadeada de tipos genericos
*
* @param <T> tipo generico
*/
public class Node<T> implements Serializable
{
/**
* Identificador de serializacao da classe
*/
private static final long serialVersionUID = 1L;
/**
* Elemento deste nodo
*/
private T element;
/**
* Proximo elemento deste nodo
*/
private Node<T> next;
/**
* Criar um nodo com um dado elemento
*
* @param element elemento deste nodo
*/
public Node(T element)
{
this(element, null);
}
/**
* Criar um nodo com um dado elemento e o proximo nodo
*
* @param element elemento deste nodo
* @param next proximo elemento deste nodo
*/
public Node(T element, Node<T> next)
{
this.element = element;
setNext(next);
}
/**
* Retornar o elemento deste nodo
*
* @return elemento deste nodo
*/
public T getElement()
{
return element;
}
/**
* Retornar o proximo elemento deste nodo
*
* @return proximo elemento deste nodo
*/
public Node<T> getNext()
{
return next;
}
/**
* Configurar o proximo elemento deste nodo
*
* @param next proximo elemento deste nodo
*/
public void setNext(Node<T> next)
{
this.next = next;
}
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
/**
* Excecao lancada pela classe Dequeue para indicar que o deque esta vazio
*/
public class EmptyDequeueException extends RuntimeException
{
/**
* Identificador de serializacao da classe
*/
private static final long serialVersionUID = 1L;
/**
* Construtor padrao
*/
public EmptyDequeueException()
{
super();
}
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
public EmptyDequeueException(String message)
{
super(message);
}
/**
* Construtor para inicializar a mensagem de erro e a causa do erro
*
* @param message mensagem de erro
* @param cause causa do erro
*/
public EmptyDequeueException(String message, Throwable cause)
{
super(message, cause);
}
/**
* Construtor para inicializar a mensagem de erro, a causa do erro,
* a supressao e o rastreamento da pilha
*
* @param message mensagem de erro
* @param cause causa do erro
* @param enableSuppression se a supressao esta ativada ou desativada
* @param writableStackTrace se o rastreamento da pilha deve ser gravavel
*/
public EmptyDequeueException(String message, Throwable cause,
boolean enableSuppression, boolean writableStackTrace)
{
super(message, cause, enableSuppression, writableStackTrace);
}
/**
* Construtor para inicializar a causa do erro
*
* @param cause causa do erro
*/
public EmptyDequeueException(Throwable cause)
{
super(cause);
}
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
/**
* Interface responsavel pela especificacao do deque
*
* @param <T> tipo generico
*/
public interface Dequeue<T>
{
/**
* Verificar se o deque esta vazio
*
* @return true se o deque esta vazio, ou false caso contrario
*/
public boolean empty();
/**
* Inserir um novo elemento no inicio do deque
*
* @param element novo elemento
*/
public void offerFirst(T element);
/**
* Inserir um novo elemento no final do deque
*
* @param element novo elemento
*/
public void offerLast(T element);
/**
* Recuperar o primeiro elemento do deque
*
* @return primeiro elemento do deque
* @throws EmptyDequeueException o deque esta vazio
*/
public T peekFirst() throws EmptyDequeueException;
/**
* Recuperar o ultimo elemento do deque
*
* @return ultimo elemento do deque
* @throws EmptyDequeueException o deque esta vazio
*/
public T peekLast() throws EmptyDequeueException;
/**
* Recuperar e remover o primeiro elemento do deque
*
* @return primeiro elemento do deque
* @throws EmptyDequeueException o deque esta vazio
*/
public T pollFirst() throws EmptyDequeueException;
/**
* Recuperar e remover o ultimo elemento do deque
*
* @return ultimo elemento do deque
* @throws EmptyDequeueException o deque esta vazio
*/
public T pollLast() throws EmptyDequeueException;
/**
* Retornar o numero de elementos do deque
*
* @return numero de elementos do deque
*/
public int size();
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
/**
* Classe responsavel pela implementacao do deque,
* utilizando uma Singly Linked List
*
* @param <T> tipo generico
*/
public class DequeueSinglyLinkedList<T> implements Dequeue<T>
{
/**
* Primeiro nodo do deque
*/
private Node<T> header;
/**
* Construtor padrao
*/
public DequeueSinglyLinkedList()
{
header = null;
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Dequeue#empty()
*/
@Override
public boolean empty()
{
return header == null;
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Dequeue#offerFirst(java.lang.Object)
*/
@Override
public void offerFirst(T element)
{
if(empty())
{
header = new Node<T>(element);
}
else
{
header = new Node<T>(element, header);
}
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Dequeue#offerLast(java.lang.Object)
*/
@Override
public void offerLast(T element)
{
if(empty())
{
header = new Node<T>(element);
}
else
{
Node<T> trailer = header;
while(trailer.getNext() != null)
{
trailer = trailer.getNext();
}
Node<T> node = new Node<T>(element);
trailer.setNext(node);
}
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Dequeue#peekFirst()
*/
@Override
public T peekFirst() throws EmptyDequeueException
{
if(!empty())
{
return header.getElement();
}
throw new EmptyDequeueException();
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Dequeue#peekLast()
*/
@Override
public T peekLast() throws EmptyDequeueException
{
if(!empty())
{
Node<T> trailer = header;
while(trailer.getNext() != null)
{
trailer = trailer.getNext();
}
return trailer.getElement();
}
throw new EmptyDequeueException();
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Dequeue#pollFirst()
*/
@Override
public T pollFirst() throws EmptyDequeueException
{
if(!empty())
{
Node<T> node = header;
header = header.getNext();
node.setNext(null);
return node.getElement();
}
throw new EmptyDequeueException();
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Dequeue#pollLast()
*/
@Override
public T pollLast() throws EmptyDequeueException
{
if(!empty())
{
Node<T> trailer = header;
Node<T> node = null;
while(trailer.getNext() != null)
{
node = trailer;
trailer = trailer.getNext();
}
if(node != null)
{
node.setNext(null);
}
else
{
header = null;
}
return trailer.getElement();
}
throw new EmptyDequeueException();
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Dequeue#size()
*/
@Override
public int size()
{
Node<T> node = header;
int count = 0;
while(node != null)
{
node = node.getNext();
count = count + 1;
}
return count;
}
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
/**
* Excecao lancada pela classe Queue para indicar que a fila esta vazia
*/
public class EmptyQueueException extends RuntimeException
{
/**
* Identificador de serializacao da classe
*/
private static final long serialVersionUID = 1L;
/**
* Construtor padrao
*/
public EmptyQueueException()
{
super();
}
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
public EmptyQueueException(String message)
{
super(message);
}
/**
* Construtor para inicializar a mensagem de erro e a causa do erro
*
* @param message mensagem de erro
* @param cause causa do erro
*/
public EmptyQueueException(String message, Throwable cause)
{
super(message, cause);
}
/**
* Construtor para inicializar a mensagem de erro, a causa do erro,
* a supressao e o rastreamento da pilha
*
* @param message mensagem de erro
* @param cause causa do erro
* @param enableSuppression se a supressao esta ativada ou desativada
* @param writableStackTrace se o rastreamento da pilha deve ser gravavel
*/
public EmptyQueueException(String message, Throwable cause,
boolean enableSuppression, boolean writableStackTrace)
{
super(message, cause, enableSuppression, writableStackTrace);
}
/**
* Construtor para inicializar a causa do erro
*
* @param cause causa do erro
*/
public EmptyQueueException(Throwable cause)
{
super(cause);
}
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
/**
* Interface responsavel pela especificacao da fila
*
* @param <T> tipo generico
*/
public interface Queue<T>
{
/**
* Verificar se a fila esta vazia
*
* @return true se a fila esta vazia, ou false caso contrario
*/
public boolean empty();
/**
* Inserir um novo elemento no fim da fila
*
* @param element novo elemento
*/
public void offer(T element);
/**
* Recuperar o elemento no inicio da fila
*
* @return elemento no inicio da fila
* @throws EmptyQueueException a fila esta vazia
*/
public T peek() throws EmptyQueueException;
/**
* Recuperar e remover o elemento no inicio da fila
*
* @return elemento no inicio da fila
* @throws EmptyQueueException a fila esta vazia
*/
public T poll() throws EmptyQueueException;
/**
* Retornar o numero de elementos da fila
*
* @return numero de elementos da fila
*/
public int size();
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
/**
* Classe responsavel pela implementacao da fila,
* utilizando uma Singly Linked List
*
* @param <T> tipo generico
*/
public class QueueSinglyLinkedList<T> extends DequeueSinglyLinkedList<T>
implements Queue<T>
{
/**
* Construtor padrao
*/
public QueueSinglyLinkedList()
{
super();
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Queue#offer(java.lang.Object)
*/
@Override
public void offer(T element)
{
offerLast(element);
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Queue#peek()
*/
@Override
public T peek() throws EmptyQueueException
{
try
{
return peekFirst();
}
catch(EmptyDequeueException exception)
{
throw new EmptyQueueException(exception);
}
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Queue#poll()
*/
@Override
public T poll() throws EmptyQueueException
{
try
{
return pollFirst();
}
catch(EmptyDequeueException exception)
{
throw new EmptyQueueException(exception);
}
}
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
/**
* Excecao lancada pela classe Stack para indicar que a pilha esta vazia
*/
public class EmptyStackException extends RuntimeException
{
/**
* Identificador de serializacao da classe
*/
private static final long serialVersionUID = 1L;
/**
* Construtor padrao
*/
public EmptyStackException()
{
super();
}
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
public EmptyStackException(String message)
{
super(message);
}
/**
* Construtor para inicializar a mensagem de erro e a causa do erro
*
* @param message mensagem de erro
* @param cause causa do erro
*/
public EmptyStackException(String message, Throwable cause)
{
super(message, cause);
}
/**
* Construtor para inicializar a mensagem de erro, a causa do erro,
* a supressao e o rastreamento da pilha
*
* @param message mensagem de erro
* @param cause causa do erro
* @param enableSuppression se a supressao esta ativada ou desativada
* @param writableStackTrace se o rastreamento da pilha deve ser gravavel
*/
public EmptyStackException(String message, Throwable cause,
boolean enableSuppression, boolean writableStackTrace)
{
super(message, cause, enableSuppression, writableStackTrace);
}
/**
* Construtor para inicializar a causa do erro
*
* @param cause causa do erro
*/
public EmptyStackException(Throwable cause)
{
super(cause);
}
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
/**
* Interface responsavel pela especificacao da pilha
*
* @param <T> tipo generico
*/
public interface Stack<T>
{
/**
* Verificar se a pilha esta vazia
*
* @return true se a pilha esta vazia, false em caso contrario
*/
public boolean empty();
/**
* Recuperar o elemento no topo da pilha
*
* @return elemento no topo da pilha
* @throws EmptyStackException a pilha esta vazia
*/
public T peek() throws EmptyStackException;
/**
* Recuperar e remover o elemento no topo da pilha
*
* @return elemento no topo da pilha
* @throws EmptyStackException a pilha esta vazia
*/
public T pop() throws EmptyStackException;
/**
* Inserir um novo elemento no topo da pilha
*
* @param element novo elemento
*/
public void push(T element);
/**
* Retornar o numero de elementos na pilha
*
* @return numero de elementos na pilha
*/
public int size();
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
/**
* Classe responsavel pela implementacao da pilha,
* utilizando uma Singly Linked List
*
* @param <T> tipo generico
*/
public class StackSinglyLinkedList<T> extends DequeueSinglyLinkedList<T>
implements Stack<T>
{
/**
* Constructor
*/
public StackSinglyLinkedList()
{
super();
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Stack#peek()
*/
@Override
public T peek() throws EmptyStackException
{
try
{
return peekFirst();
}
catch(EmptyDequeueException exception)
{
throw new EmptyStackException(exception);
}
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Stack#pop()
*/
@Override
public T pop() throws EmptyStackException
{
try
{
return pollFirst();
}
catch(EmptyDequeueException exception)
{
throw new EmptyStackException(exception);
}
}
/* (non-Javadoc)
* @see com.ybadoo.tutoriais.poo.tutorial05.exercicio28.Stack#push(java.lang.Object)
*/
@Override
public void push(T element)
{
offerFirst(element);
}
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* OpenJDK Version "1.8.0_121" *
* OpenJDK 64-Bit Server VM (build 25.121-b13, mixed mode) *
*************************************************************************/
package com.ybadoo.tutoriais.poo.tutorial05.exercicio28;
/**
* Classe responsavel pela execucao da aplicacao
*/
public class Application
{
/**
* Construtor padrao
*/
private Application()
{
}
/**
* Metodo principal da linguagem de programacao Java
*
* @param args argumentos da linha de comando (nao utilizado)
*/
public static void main(String[] args)
{
System.out.println("Queue Test");
Queue<Integer> queue = new QueueSinglyLinkedList<Integer>();
System.out.println("empty: " + queue.empty());
System.out.println("offer: 9");
queue.offer(9);
System.out.println("empty: " + queue.empty());
System.out.println("poll : " + queue.poll());
System.out.println("offer: 8");
queue.offer(8);
System.out.println("peek : " + queue.peek());
System.out.println("offer: 7");
queue.offer(7);
System.out.println("offer: 6");
queue.offer(6);
System.out.println("size : " + queue.size());
System.out.println("poll : " + queue.poll());
System.out.println("poll : " + queue.poll());
System.out.println("poll : " + queue.poll());
System.out.println("empty: " + queue.empty());
System.out.println();
System.out.println("Stack Test");
Stack<Integer> stack = new StackSinglyLinkedList<Integer>();
System.out.println("empty: " + stack.empty());
System.out.println("push : 9");
stack.push(9);
System.out.println("empty: " + stack.empty());
System.out.println("pop : " + stack.pop());
System.out.println("push : 8");
stack.push(8);
System.out.println("peek : " + stack.peek());
System.out.println("push : 7");
stack.push(7);
System.out.println("push : 6");
stack.push(6);
System.out.println("size : " + stack.size());
System.out.println("pop : " + stack.pop());
System.out.println("pop : " + stack.pop());
System.out.println("pop : " + stack.pop());
System.out.println("empty: " + stack.empty());
}
}
/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#include <string>
#ifndef EXCEPTION_HPP
#define EXCEPTION_HPP
/**
* Excecao padrao
*/
class Exception
{
public:
/**
* Construtor padrao
*/
Exception();
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
Exception(std::string message);
/**
* Retornar a mensagem de erro
*
* @return mensagem de erro
*/
std::string getMessage();
private:
/**
* Mensagem de erro
*/
std::string message;
};
#endif/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#include "Exception.hpp"
/**
* Construtor padrao
*/
Exception::Exception()
{
message = '\0';
}
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
Exception::Exception(std::string message)
{
Exception::message = message;
}
/**
* Retornar a mensagem de erro
*
* @return mensagem de erro
*/
std::string Exception::getMessage()
{
return message;
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#ifndef NODE_HPP_
#define NODE_HPP_
#include <cstdlib>
/**
* Nodo de uma lista simplesmente encadeada de tipos genericos
*
* @param <T> tipo generico
*/
template <class T> class Node
{
public:
/**
* Criar um nodo com um dado elemento
*
* @param element elemento deste nodo
*/
Node(const T element)
{
Node::element = element;
setNext(NULL);
}
/**
* Criar um nodo com um dado elemento e o proximo nodo
*
* @param element elemento deste nodo
* @param next proximo elemento deste nodo
*/
Node(const T element, Node<T>* next)
{
Node::element = element;
setNext(next);
}
/**
* Construtor por copia
*/
Node(const Node<T> &other)
{
element = other.element;
next = other.next;
}
/**
* Destrutor
*/
virtual ~Node()
{
setNext(NULL);
}
/**
* Retornar o elemento deste nodo
*
* @return elemento deste nodo
*/
T getElement() const
{
return element;
}
/**
* Retornar o proximo elemento deste nodo
*
* @return proximo elemento deste nodo
*/
Node<T>* getNext() const
{
return next;
}
/**
* Configurar o proximo elemento deste nodo
*
* @param next proximo elemento deste nodo
*/
void setNext(Node<T>* next)
{
Node::next = next;
}
private:
/**
* Elemento deste nodo
*/
T element;
/**
* Proximo elemento deste nodo
*/
Node<T>* next;
};
#endif/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#include "Exception.hpp"
#ifndef EMPTYDEQUEUEEXCEPTION_HPP
#define EMPTYDEQUEUEEXCEPTION_HPP
/**
* Excecao lancada pela classe Dequeue para indicar que o deque esta vazio
*/
class EmptyDequeueException : public Exception
{
public:
/**
* Construtor padrao
*/
EmptyDequeueException();
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
EmptyDequeueException(std::string message);
};
#endif/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#include "EmptyDequeueException.hpp"
/**
* Construtor padrao
*/
EmptyDequeueException::EmptyDequeueException()
:Exception()
{
}
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
EmptyDequeueException::EmptyDequeueException(std::string message)
:Exception(message)
{
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#ifndef DEQUEUE_HPP_
#define DEQUEUE_HPP_
#include "EmptyDequeueException.hpp"
#include "Node.hpp"
/**
* Interface responsavel pela especificacao do deque
*
* @param <T> tipo generico
*/
template <class T> class Dequeue
{
public:
/**
* Construtor padrao
*/
Dequeue()
{
header = NULL;
}
/**
* Construtor por copia
*/
Dequeue(const Dequeue<T> &other)
{
header = other.header;
}
/**
* Destrutor
*/
virtual ~Dequeue()
{
while(header != NULL)
{
Node<T>* node = header;
header = header->getNext();
free(node);
}
}
/**
* Verificar se o deque esta vazio
*
* @return true (1) se o deque esta vazio, ou false (0) caso contrario
*/
bool empty() const
{
return header == NULL;
}
/**
* Inserir um novo elemento no inicio do deque
*
* @param element novo elemento
*/
void offerFirst(const T element)
{
if(empty())
{
header = new Node<T>(element);
}
else
{
header = new Node<T>(element, header);
}
}
/**
* Inserir um novo elemento no final do deque
*
* @param element novo elemento
*/
void offerLast(const T element)
{
if(empty())
{
header = new Node<T>(element);
}
else
{
Node<T>* trailer = header;
while(trailer->getNext() != NULL)
{
trailer = trailer->getNext();
}
Node<T>* node = new Node<T>(element);
trailer->setNext(node);
}
}
/**
* Recuperar o primeiro elemento do deque
*
* @return primeiro elemento do deque
* @throws EmptyDequeueException o deque esta vazio
*/
T peekFirst() const throw (EmptyDequeueException)
{
if(!empty())
{
return header->getElement();
}
throw EmptyDequeueException();
}
/**
* Recuperar o ultimo elemento do deque
*
* @return ultimo elemento do deque
* @throws EmptyDequeueException o deque esta vazio
*/
T peekLast() const throw (EmptyDequeueException)
{
if(!empty())
{
Node<T>* trailer = header;
while(trailer->getNext() != NULL)
{
trailer = trailer->getNext();
}
return trailer->getElement();
}
throw EmptyDequeueException();
}
/**
* Recuperar e remover o primeiro elemento do deque
*
* @return primeiro elemento do deque
* @throws EmptyDequeueException o deque esta vazio
*/
T pollFirst() throw (EmptyDequeueException)
{
if(!empty())
{
Node<T>* node = header;
header = header->getNext();
T element = node->getElement();
free(node);
return element;
}
throw EmptyDequeueException();
}
/**
* Recuperar e remover o ultimo elemento do deque
*
* @return ultimo elemento do deque
* @throws EmptyDequeueException o deque esta vazio
*/
T pollLast() throw (EmptyDequeueException)
{
if(!empty())
{
Node<T>* trailer = header;
Node<T>* node = NULL;
while(trailer->getNext() != NULL)
{
node = trailer;
trailer = trailer->getNext();
}
node->setNext(NULL);
T element = trailer->getElement();
free(trailer);
return element;
}
throw EmptyDequeueException();
}
/**
* Retornar o numero de elementos do deque
*
* @return numero de elementos do deque
*/
int size() const
{
Node<T>* node = header;
int count = 0;
while(node != NULL)
{
node = node->getNext();
count = count + 1;
}
return count;
}
private:
/**
* Primeiro nodo do deque
*/
Node<T>* header;
};
#endif/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#include "Exception.hpp"
#ifndef EMPTYQUEUEEXCEPTION_HPP
#define EMPTYQUEUEEXCEPTION_HPP
/**
* Excecao lancada pela classe Queue para indicar que a fila esta vazia
*/
class EmptyQueueException : public Exception
{
public:
/**
* Construtor padrao
*/
EmptyQueueException();
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
EmptyQueueException(std::string message);
};
#endif/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#include "EmptyQueueException.hpp"
/**
* Construtor padrao
*/
EmptyQueueException::EmptyQueueException()
:Exception()
{
}
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
EmptyQueueException::EmptyQueueException(std::string message)
:Exception(message)
{
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#ifndef QUEUE_HPP_
#define QUEUE_HPP_
#include "Dequeue.hpp"
#include "EmptyDequeueException.hpp"
#include "EmptyQueueException.hpp"
/**
* Interface responsavel pela especificacao da fila
*
* @param <T> tipo generico
*/
template <class T> class Queue : private Dequeue<T>
{
public:
/**
* Construtor padrao
*/
Queue() : Dequeue<T>()
{
}
/**
* Destrutor
*/
virtual ~Queue()
{
}
/**
* Verificar se a fila esta vazia
*
* @return true (1) se a fila esta vazia, ou false (0) caso contrario
*/
bool empty() const
{
return Dequeue<T>::empty();
}
/**
* Inserir um novo elemento no fim da fila
*
* @param element novo elemento
*/
void offer(const T element)
{
Dequeue<T>::offerLast(element);
}
/**
* Recuperar o elemento no inicio da fila
*
* @return elemento no inicio da fila
* @throws EmptyQueueException a fila esta vazia
*/
T peek() const throw (EmptyQueueException)
{
try
{
return Dequeue<T>::peekFirst();
}
catch(EmptyDequeueException exception)
{
throw EmptyQueueException();
}
}
/**
* Recuperar e remover o elemento no inicio da fila
*
* @return elemento no inicio da fila
* @throws EmptyQueueException a fila esta vazia
*/
T poll() throw (EmptyQueueException)
{
try
{
return Dequeue<T>::pollFirst();
}
catch(EmptyDequeueException exception)
{
throw EmptyQueueException();
}
}
/**
* Retornar o numero de elementos da fila
*
* @return numero de elementos da fila
*/
int size() const
{
return Dequeue<T>::size();
}
};
#endif/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#include "Exception.hpp"
#ifndef EMPTYSTACKEXCEPTION_HPP
#define EMPTYSTACKEXCEPTION_HPP
/**
* Excecao lancada pela classe Stack para indicar que a pilha esta vazia
*/
class EmptyStackException : public Exception
{
public:
/**
* Construtor padrao
*/
EmptyStackException();
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
EmptyStackException(std::string message);
};
#endif/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#include "EmptyStackException.hpp"
/**
* Construtor padrao
*/
EmptyStackException::EmptyStackException()
:Exception()
{
}
/**
* Construtor para inicializar a mensagem de erro
*
* @param message mensagem de erro
*/
EmptyStackException::EmptyStackException(std::string message)
:Exception(message)
{
}/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#ifndef STACK_HPP_
#define STACK_HPP_
#include "Dequeue.hpp"
#include "EmptyDequeueException.hpp"
#include "EmptyStackException.hpp"
/**
* Interface responsavel pela especificacao da pilha
*
* @param <T> tipo generico
*/
template <class T> class Stack : private Dequeue<T>
{
public:
/**
* Constructor
*/
Stack() : Dequeue<T>()
{
}
/**
* Destructor
*/
virtual ~Stack()
{
}
/**
* Verificar se a pilha esta vazia
*
* @return true (1) se a pilha esta vazia, false (0) em caso contrario
*/
bool empty() const
{
return Dequeue<T>::empty();
}
/**
* Recuperar o elemento no topo da pilha
*
* @return elemento no topo da pilha
* @throws EmptyStackException a pilha esta vazia
*/
T peek() const throw (EmptyStackException)
{
try
{
return Dequeue<T>::peekFirst();
}
catch(EmptyDequeueException exception)
{
throw EmptyStackException();
}
}
/**
* Recuperar e remover o elemento no topo da pilha
*
* @return elemento no topo da pilha
* @throws EmptyStackException a pilha esta vazia
*/
T pop() throw (EmptyStackException)
{
try
{
return Dequeue<T>::pollFirst();
}
catch(EmptyDequeueException exception)
{
throw EmptyStackException();
}
}
/**
* Inserir um novo elemento no topo da pilha
*
* @param element novo elemento
*/
void push(const T element)
{
Dequeue<T>::offerFirst(element);
}
/**
* Retornar o numero de elementos na pilha
*
* @return numero de elementos na pilha
*/
int size() const
{
return Dequeue<T>::size();
}
};
#endif/*************************************************************************
* Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) *
* Ybadoo - Solucoes em Software Livre (ybadoo.com.br) *
* *
* Permission is granted to copy, distribute and/or modify this document *
* under the terms of the GNU Free Documentation License, Version 1.3 or *
* any later version published by the Free Software Foundation; with no *
* Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A *
* A copy of the license is included in the section entitled "GNU Free *
* Documentation License". *
* *
* Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) *
* g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 *
*************************************************************************/
#include <iostream>
#include "EmptyQueueException.hpp"
#include "EmptyStackException.hpp"
#include "Queue.hpp"
#include "Stack.hpp"
using namespace std;
/**
* Metodo principal da linguagem de programacao C++
*
* @param argc quantidade de argumentos na linha de comando (nao utilizado)
* @param argv argumentos da linha de comando (nao utilizado)
*/
int main(int argc, char** argv)
{
cout << "Queue Test" << endl;
Queue<int>* queue = new Queue<int>();
try
{
cout << "empty: " << queue->empty() << endl;
cout << "offer: 9" << endl;
queue->offer(9);
cout << "empty: " << queue->empty() << endl;
cout << "poll : " << queue->poll() << endl;
cout << "offer: 8" << endl;
queue->offer(8);
cout << "peek : " << queue->peek() << endl;
cout << "offer: 7" << endl;
queue->offer(7);
cout << "offer: 6" << endl;
queue->offer(6);
cout << "size : " << queue->size() << endl;
cout << "poll : " << queue->poll() << endl;
cout << "poll : " << queue->poll() << endl;
cout << "poll : " << queue->poll() << endl;
cout << "empty: " << queue->empty() << endl;
}
catch(EmptyQueueException exception)
{
cerr << "EmptyQueueException" << endl;
}
delete queue;
cout << endl;
cout << "Stack Test" << endl;
Stack<int>* stack = new Stack<int>();
try
{
cout << "empty: " << stack->empty() << endl;
cout << "push : 9" << endl;
stack->push(9);
cout << "empty: " << stack->empty() << endl;
cout << "pop : " << stack->pop() << endl;
cout << "push : 8" << endl;
stack->push(8);
cout << "peek : " << stack->peek() << endl;
cout << "push : 7" << endl;
stack->push(7);
cout << "push : 6" << endl;
stack->push(6);
cout << "size : " << stack->size() << endl;
cout << "pop : " << stack->pop() << endl;
cout << "pop : " << stack->pop() << endl;
cout << "pop : " << stack->pop() << endl;
cout << "empty: " << stack->empty() << endl;
}
catch(EmptyStackException exception)
{
cerr << "EmptyStackException" << endl;
}
delete stack;
return 0;
}##########################################################################
# Copyright (C) 2009/2025 - Cristiano Lehrer (cristiano@ybadoo.com.br) #
# Ybadoo - Solucoes em Software Livre (ybadoo.com.br) #
# #
# Permission is granted to copy, distribute and/or modify this document #
# under the terms of the GNU Free Documentation License, Version 1.3 or #
# any later version published by the Free Software Foundation; with no #
# Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A #
# A copy of the license is included in the section entitled "GNU Free #
# Documentation License". #
# #
# Ubuntu 16.10 (GNU/Linux 4.8.0-39-generic) #
# gcc/g++ (Ubuntu 6.2.0-5ubuntu12) 6.2.0 20161005 #
##########################################################################
g++ -o Exception.o -c Exception.cpp
g++ -o EmptyDequeueException.o -c EmptyDequeueException.cpp
g++ -o EmptyQueueException.o -c EmptyQueueException.cpp
g++ -o EmptyStackException.o -c EmptyStackException.cpp
g++ -o Application.o -c Application.cpp
g++ -o application Exception.o EmptyDequeueException.o EmptyQueueException.o EmptyStackException.o Application.oDeitel, H. M. (2003). Java, como programar. 4ª edição. Porto Alegre: Bookman. 1.386 páginas.
Goodrich, Michael. (2007). Estrutura de Dados e Algoritmos em Java. 4ª edição. Porto Alegre: Bookman. 600 páginas.
Ybadoo - Soluções em Software Livre • Copyright 2009/2025 • 