Answer Happy

implement method
Public c static <E>
int removeMiddle(Stack<E> s)
to remove the element in the middle of stack and
return it without changing the order
test method in main
public class Test
{
public static void main(String[]
args) {
LinkedQueue<Character>
q1=new LinkedQueue<>();
Stack<Integer> stackInt
= new LinkedStack<Integer>();
stackInt.push(10);
stackInt.push(20);
stackInt.push(40);
stackInt.push(30);
System.out.println("searchStack: "
+ searchStack(stackInt,400));
System.out.println(postfix("57+"));
//removeEven(stackInt );
for (int i = 0; i
< stackInt.size(); i++) {
System.out.println(i);
}
//System.out.println(stackInt);
}
public static <E>boolean searchStack(Stack<E>
s, E e) {
Stack<E> tmpStack
= new LinkedStack<E>();
boolean found=false;
while (!s.isEmpty()) {
if (s.top().equals(e)) {
found = true;
break;
}
tmpStack.push(s.pop());
}
while (!tmpStack.isEmpty())
s.push(tmpStack.pop());
return found;
}
public static <E>boolean remove(Stack<E>
s, E e) {
Stack<E> tmpStack
= new LinkedStack<E>();
boolean found=false;
while (!s.isEmpty()) {
if (s.top().equals(e)) {
found = true;
s.pop();
break;
}
tmpStack.push(s.pop());
}
while (!tmpStack.isEmpty())
s.push(tmpStack.pop());
return found;
}
public static <E>boolean searchQueue(Queue<E>
q, E e) {
Queue<E> tmp
= new LinkedQueue<E>();
boolean found=false;
while (!q.isEmpty()) {
if (q.first().equals(e)) {
found = true;
break;
}
tmp.enqueue(q.dequeue()); //check
}
while (!tmp.isEmpty())
q.enqueue(tmp.dequeue());
return found;
}
public static <E>void reverseQueue(Queue<E>
q){
Stack<E>
tmpStack= new LinkedStack<E>();
while (!q.isEmpty())
tmpStack.push(q.dequeue());
while (!tmpStack.isEmpty())
q.enqueue(tmpStack.pop());
}
public static <E>void removeEven(Stack<Integer>
s) {
Stack<Integer> tmp
= new LinkedStack<Integer>();
while (!s.isEmpty()) {
if (s.top()%2!=0)
tmp.push(s.pop());
else
s.pop();
}
while (!tmp.isEmpty())
s.push(tmp.pop());
}
public static <E>boolean recursivesearchStack(Stack<E>
s, E e) {
if (!s.isEmpty())
return false;
if (s.top().equals(e))
return true;
E t=s.pop();
boolean found=recursivesearchStack(s,
e);
s.push(t);
return found;
}
public static double postfix(String
s) {
Stack<Double> st
= new LinkedStack<Double>();
for (int i=0;i<s.length();i++)
{
char c = s.charAt(i);
if (Character.isDigit(c)) {
double x=c-'0';
st.push(x);
//st.push((double) c);
}
else {
double val1= st.pop();
double val2= st.pop();
switch(c) {
case '+':st.push(val1+val2);break;
case '-':st.push(val1-val2);break;
case '*':st.push(val1*val2);break;
case '/':st.push(val1/val2);break;
}
}
}
return st.pop();
}
}
public class LinkedStack<E> implements Stack<E>
{
private SinglyLinkedList<E> list
= new SinglyLinkedList<>( ); // an
empty list
public LinkedStack( ) { } // new stack
relies on the initially empty list
public int size(
)
{
return list.size( );
}
public boolean isEmpty(
)
{
return list.isEmpty( );
}
public void push(E
element)
{
list.addFirst(element);
}
public E top( )
{
return list.first( );
}
public E pop( ) {
return list.removeFirst( );
}
}
/*
* A collection of objects that are inserted and removed
according to the last-in
* first-out principle. Although similar in purpose, this
interface differs from
* java.util.Stack.
*
* @author Michael T. Goodrich
* @author Roberto Tamassia
* @author Michael H. Goldwasser
*/
public interface Stack<E>
{
/**
* Returns the number of elements in the stack.
* @return number of elements in the
stack
*/
int size( );
/**
* Tests whether the stack is empty.
* @return true if the stack is empty,
false otherwise
*/
boolean isEmpty( );
/**
* Inserts an element at the top of the stack.
* @param e the element to be
inserted
*/
void push(E e);
/**
* Returns, but does not remove, the element at the top of the
stack.
* @return top element in the stack
(or null if empty)
*/
E top( );
/**
* Removes and returns the top element from the stack.
* @return element removed (or null if
empty)
*/
E pop( );
}
public class SinglyLinkedList<E>
{
private Node<E>
head=null;
private Node<E>
tail=null;
private int size=0;
public int size()
{ return size;}
public boolean isEmpty(){ return size==0;}
public E first()
{
if (isEmpty()) return null;
return head.getElement();
}
public E last()
{
if (isEmpty()) return null;
return tail.getElement();
}
public void addFirst(E
e)
{
head=new Node<>(e,head);
if(size==0)
tail=head;
size++;
}
public void addLast(E
e)
{
Node<E>
newest=new Node<>(e,null);
if(isEmpty())
head=newest;
else
tail.setNext(newest);
tail=newest;
size++;
}
public E removeFirst()
{
if(isEmpty()) return null;
E answer=head.getElement();
head=head.getNext();
size--;
if (size==0)
tail=null;
return answer;
}
}