Boa tarde pessoal, queria ajuda em um exercício

Cara, não tem muito o que fazer não.
Como pode você ser novo e estar vendo collections/estrutura de dados?
Algo de errado não está certo aí.

Não entendi os risos.
Estrutura de dados é uma parte bem teórica da coisa. Entender qual implementação é uma lista, uma fila, uma pilha e etc é algo bem menos prático. A prática só vai consolidar essa base.

Implemente um projeto no qual serão inseridos números de forma ordenada, e que atenda as especificações a seguir:

<strong>Passo 1:</strong>  Insira os números [1, 2, 3, 4 e 5] em uma lista - com 5 células;

<strong>Passo 2:</strong>  Remova todos os dados da lista e insira-os em uma Pilha - com 5 células. Deve-se sempre remover os dados da célula inicial da lista;

<strong>Passo 3:</strong>  Remova os dados da Pilha e insira-os em uma Fila - com 10 células);

<strong>Passo 4:</strong>  Insira os números [6, 7, 8, 9 e 10] na lista;

<strong>Passo 5:</strong>  Repita os passos 2 e 3.

<strong>Passo 6:</strong>  Exiba todos os números que foram inseridos na fila.

Analise a ordem dos números exibidos e verifique se estão na mesma forma que foram inseridos. Se a exibição foi diferente, justifique o ocorrido.

O programa desenvolvido pelo aluno e a sua justificativa deverá ser postado em um ambiente virtual. Esse programa será avaliado pelo tutor responsável pela disciplina.
eu queria a resposta dessa questão, poderia me ajudar?

E por que você não faz, posta aqui o que fez e espera o pessoal comentar com o que pode melhorar, o que está correto e o que está errado?

porque eu não sei fazer

E nunca vai aprender se insistir em ter/ver as coisas prontas.
Ou você põe a mão, estuda, erra e vai consertando os erros até chegar no resultado, ou não aprende.

qual programa posso fazer essa lista , no excel?

Esquece. Precisa estudar primeiro.

Se o excel facilitar seu aprendizado, é uma alternativa.

eu consegui fazer uma lista em java, mas nao sei como remover e inserir em uma pilha, mas estou tentando

package ed;

public class ED {

    public static void main(String[] args) {
      int n[] = {1,2,3,4,5};
      
      for(int i=1; i<=5; i++){
          System.out.print(i + " ");
      }            
    }    
}

A lista não é o componente ideal para representar uma pilha.
Para isto, existe a classe Stack.
Dá para fazer? Sim. É o ideal? Não.

vlw obrigado pela dica

E ai @Guilherme_Oliveira conseguiu? eu também não consigo fazer essa interação com fila e pilha, tá osso

Você precisa implementar sua propria fila e pilha ou pode utilizar a Queue e Stack do pacote java.util?

eu acho que pode mano, pegar a API pronta né e implementar lá

Também estou com esse enrosco, uma covardia colocar esse conteúdo para quem tem pouca ou nenhuma base de programação.

Se especificarem a dúvida vão ajudar com certeza. Agora querer aula particular grátis pra todo o exercício já é demais. Tem que cobrar de quem estão pagando.

Como vao adivinhar onde ficou com dúvida? Colocando o exercício sem especificar a dúvida ou o que tentou dá entender que quer ajuda especial pra todo o trabalho.

@javaflex, a dúvida aqui é como fazer essa lista de tamanho 5 com 5 elementos se portar como uma pilha e depois como fila. so isso

Entendo que pra quem inicia acha que é “só isso”. Isso é bem abrangente, tem que estudar sobre estrutura de dados antes. Se pesquisar no google vai encontrar muito conteúdo e até aulas.

Sei o que é lista, Stack, Queue e como se comportam o problema é aplicar isso kk

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.

Concordo. Eu já faço isso. Eu ainda tenho 4 dias para entregar essa atividade, uma hora ou outra eu consigo.

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.

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.

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();

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 ?

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.

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.

image.png1280×1024 140 KB

Não sei se vai dar pra vizualizar mas essa forma de criar uma lista esta correta ?

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?

Olha eu acho que conseguir fazer da seguinte forma

LISTA:

image.png1280×1024 145 KB

Como pode perceber o resultado da a mesma sequencia de elementos inseridos .

@Yago_Rodrigues o caminho é esse, mas a idéia é que vc tire da lista um elemento e esse mesmo elemento vc insira na pilha e assim por diante. Seria algo assim:

ArrayList<Integer> lista = new ArrayList<>(5);
ArrayDeque<Integer> pilha = new ArrayDeque<>(5);
ArrayDeque<Integer> fila = new ArrayDeque<>(10);

lista.add(1);
lista.add(2);
lista.add(3);
lista.add(4);
lista.add(5);

while(!lista.isEmpty()) {
    int elemento = lista.remove(0);
    pilha.push(elemento);
}

while(!pilha.isEmpty()) {
    int elemento = pilha.pop();
    fila.add(elemento);
}

Obs.: Sempre que forem compartilhar código, não coloquem prints, por favor

Hunn, entendi, valeu !

Fiz uma correção, na fila vc usa o metodo add ao inves do push.

package itemdalista2;

import java.util.ArrayDeque;
import java.util.ArrayList;

public class ItemDaLista2 {

public static void main(String[] args) {
    ArrayList<Integer> lista = new ArrayList<>(5);
    ArrayDeque<Integer> pilha = new ArrayDeque<>(5);
    ArrayDeque<Integer> fila = new ArrayDeque<>(10);
    
    lista.add(1);
    lista.add(2);
    lista.add(3);
    lista.add(4);
    lista.add(5);

    while(!lista.isEmpty()) {
        int elemento = lista.remove(0);
        pilha.push(elemento);
    }

    while(!pilha.isEmpty()) {
        int elemento = pilha.pop();
        fila.add(elemento);
    }
    lista.add(6);
    lista.add(7);
    lista.add(8);
    lista.add(9);
    lista.add(10);

    while(!lista.isEmpty()) {
        int elemento = lista.remove(0);
        pilha.push(elemento);
    }

    while(!pilha.isEmpty()) {
        int elemento = pilha.pop();
        fila.add(elemento);
    }
    System.out.println(fila);
}

}

Cuja saída foi :
[5, 4, 3, 2, 1, 10, 9, 8, 7, 6]
CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)

Coloca essa linha dentro dos while pra vc acompanhar o que aconteceu.

System.out.printf("Lista: %s\nPilha: %s\nFila: %s\n\n", lista, pilha, fila);

Na pilha o último a entrar é o primeiro a sair, “Last In, First Out”, muito bom cara, um dia vou aprender a programa no nível de vocês. Muito obrigado por me ajudar!

Como criar uma fila:

Queue<TipoDeDado> fila= new LinkedList<>();

Como adicionar um elemento ao final da fila:

fila.add(elementoQueDesejaAdicionar);

Como remover um elemento do início da fila:

TipoDeDado elementoRemovido = fila.remove();

Como criar uma pilha:

Stack<TipoDeDado> pilha= new Stack<>();

Como adicionar um elemento ao topo da pilha:

pilha.push(elementoQueDesejaAdicionar);

Como remover um elemento do topo da pilha:

TipoDeDado elementoRemovido = pilha.pop();

Moço eu queria te dar um abraço! OBRIGADA!!!