Exercício para certificação

12 de abril de 2018 10 respostas

Ronaldo_B_Teichrieb 12 de abril de 2018

Bom dia, alguém saberia a resposta para essa questão, por gentileza?

De acordo com o trecho a seguir, mostre como ficaria o conteúdo do vetor stack do objeto s (classe Stack - implementação de pilha com alocação estática) após a execução do código abaixo.

public static void main(String[] args) {

Stack s = new Stack(5);

Object valor;

try{

s.push(“7”);

s.push(“3”);

s.push(“1”);

s.push(“2”);

s.push(“5”);

} catch (OverflowException e) {

System.out.println(e);

}

try {

valor=s.pop();

s.pop();

} catch (UnderflowException e)

{

System.out.println(e);

}

try {

s.push(“8”);

s.push(valor);

} catch (OverflowException e) {

System.out.println(e);

}

//Observação: O vetor de uma pilha é representado verticalmente, com topo em cima da pilha.

10 Respostas

wldomiciano 12 de abr. de 2018

Acredito que está faltando informação sobre o exercicio.

Cadê a implementação das classes Stack, OverflowException e UnderflowException?

Ronaldo_B_Teichrieb 12 de abr. de 2018

Tens razão wldomiciano

public class Stack {
private Object s[];

private int top = -1;

public Stack(int size) {
	s = new Object[size];
}

public boolean isEmpty() {
	if (top == -1)
		return true;
	return false;
}

public boolean isFull() {
	if (top == s.length - 1)
		return true;
	return false;
}

public void push(Object obj) throws OverflowException {
	if (!isFull()) {
		s[++top] = obj;
	} else
		throw new OverflowException();
}

public Object pop() throws UnderflowException {
	if (!isEmpty()) {
		Object o = s[top];
		s[top] = null;
		top--;
		return o;
	} else
		throw new UnderflowException();

}

public static void main(String args[]) {
	Stack s = new Stack(5);
	try {
		s.pop();
	} catch (UnderflowException e) {
		System.out.println(e.toString());
	}
	try {
		s.push("1");
		s.push("2");
		s.push("3");
		s.push("4");
		s.push("5");
	} catch (OverflowException e) {
		System.out.println(e.toString());
	}
	try {
		s.pop();
		s.pop();
	} catch (UnderflowException e) {
		System.out.println(e.toString());
	}
	try {
		s.push("6");
	} catch (OverflowException e) {
		System.out.println(e.toString());
	}
	try {
		s.pop();
		s.pop();
		s.pop();
		s.pop();
		s.pop();
	} catch (UnderflowException e) {
		System.out.println(e.toString());
	}
}

}

public class OverflowException extends Exception {

public String toString (){

return “OVERFLOW!”;

}

}

public class UnderflowException extends Exception {

public String toString() {

return “UNDERFLOW!”;

}

}

Mike 12 de abr. de 2018

@wldomiciano @Ronaldo_B_Teichrieb
A classe Stack existe e esta no pacote java.util, já essas exceptions não existem mesmo

Edit: Vi seu post do código depois

Ronaldo_B_Teichrieb 12 de abr. de 2018

Verdade Mike, faz parte do pacote java mesmo

Ronaldo_B_Teichrieb 12 de abr. de 2018

Tem outra questão, que estou desde ontem ao meio dia tentando resolver, e também não consigo!
Obs.: A classe queue também faz parte do pacote java.

Crie o método cuja assinatura está a seguir e inclua-o na classe Queue.

public Queue makeQueueFromStack(Stack s);

O método deve retornar uma fila com o conteúdo da pilha recebida por parâmetro, invertida, ou seja, o que está no topo da pilha deve estar no final da fila.

Ronaldo_B_Teichrieb 12 de abr. de 2018

Classe Queue

public class Queue {
protected int first = 0, last = -1;

protected Object q[];

public Queue(int size) {
	q = new Object[size];
}

public boolean isEmpty() {
	if (last == first - 1)
		return true;
	return false;
}

public boolean isFull() {
	if (last == q.length - 1)
		return true;
	return false;
}

/* Insert the element in the final of this queue */
public void enqueue(Object element) throws OverflowException {
	if (isFull()) {
		throw new OverflowException();
	} else {
		last++;
		q[last] = element;
	}
}

/* Retrives and remove the first element of this queue */
public Object dequeue() throws UnderflowException {
	if (isEmpty()) {
		throw new UnderflowException();
	} else {
		Object o = q[first];
		q[first] = null;
		first++;
		return o;
	}
}



public Queue merge(Queue q1, Queue q2){
	Queue q3 = new Queue(30);
	return q3;
	
}

public static void main(String args[]) {
	Queue q = new Queue(5);
	System.out.println("Vazia=" + q.isEmpty());
	try {
		q.enqueue("1");
		q.enqueue("2");
		q.enqueue("3");
		q.enqueue("4");
	} catch (OverflowException e) {
		System.out.println(e.toString());
	}
	try {
		q.dequeue();
		q.dequeue();
		System.out.println(q.isEmpty());
		q.dequeue();
		q.dequeue();
		q.dequeue();
	} catch (UnderflowException e) {
		System.out.println(e.toString());
	}
	System.out.println("Vazia=" + q.isEmpty());
	try {
		q.enqueue("3");
		q.enqueue("4");
	} catch (OverflowException e) {
		System.out.println(e.toString());
	}

}

}

wldomiciano 12 de abr. de 2018

@mike, eu sabia que a Stack do exercicio não era a java.util.Stack, pois a java.util.Stack, além de genérica, não tem constructor com int como parametro.

@Ronaldo_B_Teichrieb, não sei se entendi bem a questão, mas pra mim, ele quer saber como ficou o conteúdo da variavel abaixo:

private Object s[];

Acrescentei a seguinte linha ao final do método main pra averiguar isso:

System.out.println(Arrays.toString( s.s ) );

E o resultado foi:

UNDERFLOW!
UNDERFLOW!
[null, null, null, null, null]

Então podemos constatar que:

Primeiro criamos uma Stack com capacidade 5.
No primeiro pop() a Stack vai estar vazia e vai imprimir o primeiro “UNDERFLOW!”.
Em seguida 5 itens são adicionados. 5 é o limite, então tá tudo certo e nada acontece.
Depois são tirados 2 itens, deixando a Stack com 3.
Aí vem mais um push() deixando-a com 4 itens.
Depois vem 5 pop(). Como a Stack só tinha 4 itens, no quinto pop ocorre o segundo “UNDERFLOW!”.

E é isso eu acho.

wldomiciano 12 de abr. de 2018

Eu me perdi um pouco nesse negócio de pilha invertida, mas só pra te dar uma luz eu tentei fazer aqui.

Primeiro eu acrescentei um método em Stack pra saber quantos elementos ela possui.

public int size() {
    return top + 1;
}

Também acrescentei um toString() nas duas pra saber o que tá acontecendo dentro delas.

// Queue
@Override
public String toString() {
    return Arrays.toString(q);
}

// Stack
@Override
public String toString() {
    return Arrays.toString(s);
}

O método pedido ficou assim:

public static Queue makeQueueFromStack(Stack s) {
    Queue temp = new Queue( s.size() );

    try {
        while (!s.isEmpty())
            temp.enqueue(s.pop());
    } catch (OverflowException | UnderflowException e) {
        System.out.println( e.toString() );
    }

    return temp;
}

O teste eu fiz assim:

class Program {
    public static void main(String[] args) throws Exception {
        Stack s = new Stack(5);

        s.push(1);
        s.push(2);
        s.push(3);
        s.push(4);
        s.push(5);

        System.out.println(s);

        Queue q = Queue.makeQueueFromStack(s);
        
        System.out.println(q);
    }
}

E o resultado foi:

[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

Não sei se a ordem da Queue é a esperada, mas fiz do jeito mais simples que pensei e acho que pode lhe dar uma idéia do caminho.

Qualquer coisa, faz outra pergunta só pra essa questão apresentando as soluções que tentou e os problemas que teve.

Ronaldo_B_Teichrieb 12 de abr. de 2018 1 like

Beleza, vou praticar com esse código para ver como funciona! Eu uso o netbeans, vocês indicam algum outro?

wldomiciano 13 de abr. de 2018

Uso IntelliJ IDEA.

Criado 12 de abril de 2018

Ultima resposta 13 de abr. de 2018

Respostas 10

Participantes 3

10 Respostas

Topicos relacionados