Exercício para certificação

[Ronaldo_B_Teichrieb]

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.

[wldomiciano]

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

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

[Ronaldo_B_Teichrieb]

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]

@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]

Verdade Mike, faz parte do pacote java mesmo

[Ronaldo_B_Teichrieb]

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]

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]

@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]

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]

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

[wldomiciano]

Uso IntelliJ IDEA.