Sei que o sistema de ensino costuma ser ruim, mas nao tem jeito, busque conteúdos na internet. Na minha época nem tinha essas facilidades de google e eu tinha que ir pra biblioteca física.
1 curtida
Concordo. Eu já faço isso. Eu ainda tenho 4 dias para entregar essa atividade, uma hora ou outra eu consigo.
2 curtidas
Consegue, é fácil achar tutoriais ensinando esses assuntos, a exemplo do que o colega citou. Depois que tentar e tiver algum problema específico na execuçao do seu código, fique livre para postar dúvidas.
1 curtida
Sugestão de bibliografia: Java Como Programar 8, Cap. 22 - Estruturas de Dados Genéricas Personalizadas, pág. 695 - 714.
697 - Listas Vinculadas;
704 - Pilhas;
707 - Filas;
709 - Árvores.
1 curtida
Pelo que entendi do seu exercicio, não é preciso implementar uma lista, uma pilha e uma fila do zero.
Parece que vc só precisa observar como cada estrutura se comporta, neste caso podemos usar as ferramentas que o Java nos oferece.
Lista
Para representar a lista, vc pode usar um java.util.ArrayList:
// Cria lista com capacidade para 5 elementos
ArrayList<Integer> lista = new ArrayList<>(5);
Para adicionar elementos, usa-se o método add(), da seguinte forma:
// Adiciona 1 ao final da lista
lista.add(1);
Para remover os elementos da lista, vc pode usar o método remove(). O código abaixo remove o primeiro elemento da lista:
// remove o primeiro elemento
lista.remove(0);
Para remover todos, um por um, como pede o exercicio, vc pode usar o remove() dentro de um while:
// Enquando lista não estiver vazia
while(!lista.isEmpty()) {
// Remova o primeiro elemento
int elemento = lista.remove(0);
}
Pilha
Tanto para a pilha quanto pra fila, vc pode usar a classe ArrayDeque. Vamos focar aqui na função de pilha.
Obs.: O Java possui a java.util.Stack, mas a documentação recomenda usar implementações de java.util.Deque como a ArrayDeque mencionada aqui.
Eis um trecho da documentação:
A more complete and consistent set of LIFO stack operations is provided by the Deque interface and its implementations, which should be used in preference to this class. For example:
O trecho abaixo mostra como criar a estrutura, adicionar e remover elementos:
// Cria deque com capacidade para 5 elementos
ArrayDeque<Integer> pilha = new ArrayDeque<>(5);
// Insere 1 no topo da pilha
pilha.push(1);
// Enquando pilha não estiver vazia
while(!pilha.isEmpty()) {
// Remove o elemento do topo da pilha
int elemento = pilha.pop();
}
Fila
Vamos usar a mesma classe anterior para representar uma fila, o que diferenciará o comportamento serão os métodos que usaremos, veja:
// Cria deque com capacidade para 10 elementos
ArrayDeque<Integer> fila = new ArrayDeque<>(10);
// Insere 1 no fim da fila
fila.add(1);
// Remove o elemento do inicio da fila
int elemento = fila.remove();
3 curtidas
Cara muito obrigado, isso vai me ajudar bastante , eu tenho uma outra dúvida, será que da para fazer isso tudo em um só processo? ou é necessário tipo criar um projeto, no caso eu uso o NetBeans, e depois criar outras 2 classes que vão interagir com a classe principal? ou da pra fazer isso em uma só estrutura ?
2 curtidas
Você pode fazer do jeito que achar melhor, o importante é vc conseguir visualizar e descrever o que aconteceu. Eu faria numa classe só, pra manter simples.
1 curtida
ok, também prefiro. Obrigado
man eu to fazendo essa atv agora cara e tambem estou com as mesmas duvidas que voce! estou nela desde as 9 da manha rsrs ja vi diversos videos mais ainda não consigo resolver essa questão!
É isso que eu tbm quero saber … No caso a atv pede pra nos criarmos uma lista com 5 celulas… e depois “remover” os dados da lista e enseri-las em pilhas com 5 celulas deve-se sempre remover os dados da celula inicial da lista e depois remover os dados da pilha e enserir em uma fila com 10 celulas…
Pelo que eu entendi a atv pede pra criarmos 3 tipos de estruturas passando de uma pra outra ? e quando eles pedem pra remover os dados da lista é apagar literalmente os numeros ? e deixa-la em branco ? Pra no final sobrar apenas a fila com 10 celulas contento os dados que foram passados da pilha ?
Poxa eu achei essa atv muito complexa pra quem está apredendo agora estrutura de dados! alguem da uma base ai PFV
Exatamente, pelo menos foi o que eu entendi.
Sim e sim.
Além da fila, vc vai ficar com uma lista e uma fila vazias.
1 curtida
Sim. Mas é só o primeiro passo.
Man tu não quer me passar seu zap pra nós tentarmos resolver essa atv juntos ?
package listapilhafila;
import java.util.ArrayDeque;
import java.util.ArrayList;
public class ListaPilhaFila {
@SuppressWarnings("empty-statement")
public static void main(String[] args) {
ArrayList<Integer> lista = new ArrayList<>(5);
System.out.println("Inserindo os numeros 1,2,3,4,5 na lista");
lista.add(1);
lista.add(2);
lista.add(3);
lista.add(4);
lista.add(5);
System.out.println(lista);
System.out.println("--------------------------------------------");
System.out.println("Removendo os dados da celula inicial da lista");
while(!lista.isEmpty()) {
int elemento = lista.remove(0);
System.out.println(lista);
}
System.out.println("Lista vazia!");
System.out.println("--------------------------------------------");
System.out.println("Inserindo os dados da lista na pilha");
ArrayDeque<Integer> pilha = new ArrayDeque<>(5);
pilha.push(1);
pilha.push(2);
pilha.push(3);
pilha.push(4);
pilha.push(5);
System.out.println(pilha);
System.out.println("--------------------------------------------");
System.out.println("Remove os dados da pilha");
pilha.clear();
System.out.println(pilha);
System.out.println("--------------------------------------------");
while(!pilha.isEmpty()) {
int elemento = pilha.pop();
System.out.println(pilha);
}
System.out.println("Inserindo os dados da pilha na fila");
ArrayDeque<Integer> fila = new ArrayDeque<>(10);
fila.add(1);
fila.add(2);
fila.add(3);
fila.add(4);
fila.add(5);
fila.add(0);
fila.add(0);
fila.add(0);
fila.add(0);
fila.add(0);
System.out.println(fila);
System.out.println("--------------------------------------------");
System.out.println("Adicionando os numeros 6,7,8,9,10 na lista");
lista.add(6);
lista.add(7);
lista.add(8);
lista.add(9);
lista.add(10);
System.out.println(lista);
System.out.println("--------------------------------------------");
System.out.println("Removendo os dados das celulas iniciais da lista");
while(!lista.isEmpty()) {
int elemento = lista.remove(0);
System.out.println(lista);
}
System.out.println("Lista vazia!");
System.out.println("--------------------------------------------");
System.out.println("Inserindo os dados da lista na pilha");
pilha.push(6);
pilha.push(7);
pilha.push(8);
pilha.push(9);
pilha.push(10);
System.out.println(pilha);
System.out.println("--------------------------------------------");
System.out.println("Removendo os dados da pilha");
pilha.clear();
System.out.println(pilha);
System.out.println("--------------------------------------------");
System.out.println("inserindo os dados da pilha na fila");
fila.add(0);
fila.add(0);
fila.add(0);
fila.add(0);
fila.add(0);
fila.add(6);
fila.add(7);
fila.add(8);
fila.add(9);
fila.add(10);
System.out.println(fila);
}
}
**Saída do programa **
Inserindo os numeros 1,2,3,4,5 na lista
[1, 2, 3, 4, 5]
--------------------------------------------
Removendo os dados da celula inicial da lista
[2, 3, 4, 5]
[3, 4, 5]
[4, 5]
[5]
[]
Lista vazia!
--------------------------------------------
Inserindo os dados da lista na pilha
[5, 4, 3, 2, 1]
--------------------------------------------
Remove os dados da pilha
[]
--------------------------------------------
Inserindo os dados da pilha na fila
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
--------------------------------------------
Adicionando os numeros 6,7,8,9,10 na lista
[6, 7, 8, 9, 10]
--------------------------------------------
Removendo os dados das celulas iniciais da lista
[7, 8, 9, 10]
[8, 9, 10]
[9, 10]
[10]
[]
Lista vazia!
--------------------------------------------
Inserindo os dados da lista na pilha
[10, 9, 8, 7, 6]
--------------------------------------------
Removendo os dados da pilha
[]
--------------------------------------------
inserindo os dados da pilha na fila
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 8, 9, 10]
CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)
A outra forma de resultado que eu acho que é o correto, onde eu não adiciono os 0 na fila é essa:
inserindo os dados da pilha na fila
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)
O que vocês acham? tá certo?