stack and queue

1. publicstatic <E> void insertFirst(Queue<E> q, E e) { Queue<E> tmp = new LinkedQueue<E>(); tmp.enqueue(e); while (!q.isEmpty()) tmp.enqueue(q.dequeue()); while (!tmp.isEmpty()) q.enqueue(tmp.dequeue()); } publicstatic <E> void insertSecond(Queue<E> q, E e) { if (q.size() >= 1) { Queue<E> tmp = new LinkedQueue<E>(); tmp.enqueue(q.dequeue()); tmp.enqueue(e); while (!q.isEmpty()) tmp.enqueue(q.dequeue()); while (!tmp.isEmpty()) q.enqueue(tmp.dequeue()); } else { System.out.println("The queue should has at least one element"); } }

2. publicstatic <E> void removeLastTwo(Queue<E> q) { if (q.size() >= 2) { Queue<E> tmp = new LinkedQueue<E>(); while (q.size() > 2) tmp.enqueue(q.dequeue()); while (!q.isEmpty()) q.dequeue(); while (!tmp.isEmpty()) q.enqueue(tmp.dequeue()); } else { System.out.println("should has at least two elements"); } } publicstatic <E> E removeMiddle(Queue<E> q) { if (q.size() % 2 == 1) { Queue<E> tmp = new LinkedQueue<E>(); int mid = q.size() / 2;// 2 for (int i = 1; i <= mid; i++) tmp.enqueue(q.dequeue()); E e = q.dequeue(); for (int i = 1; i <= mid; i++) tmp.enqueue(q.dequeue()); while (!tmp.isEmpty()) q.enqueue(tmp.dequeue()); return e; } else { System.out.println("the queue should has odd number of elements"); returnnull; } }

3. publicstatic <E> void removeThree(Stack<E> s) { if (s.size() >= 3) { Stack<E> tmp = new LinkedStack<E>(); while (s.size() > 3) tmp.push(s.pop()); while (!s.isEmpty()) s.pop(); } else { System.out.println("the stack should has at least three elements"); } while (!tmp.isEmpty()) s.push(tmp.pop()); }

4. publicstatic <E> boolean same(Stack<E> s1, Stack<E> s2) { if (s1.size() != s2.size()) returnfalse; Stack<E> t1 = new LinkedStack<E>(); Stack<E> t2 = new LinkedStack<E>(); boolean same = true; while (!s1.isEmpty()) { if (s1.top() != s2.top()) { same = false; break; } t1.push(s1.pop()); t2.push(s2.pop()); } while (!t1.isEmpty()) { s1.push(t1.pop()); s2.push(t2.pop()); } return same; }

5. With Recursion publicstaticvoid removeNegatives(Stack<Integer> s) { if (s.isEmpty()) return; else { int n = s.pop(); removeNegatives(s); if (n > 0) s.push(n); } } publicstaticvoid removeLessThan100(Stack<Integer> s) { if (s.isEmpty()) return; else { int n = s.pop(); removeLessThan100(s); if (n >=100) s.push(n); } }

6. publicstaticvoid removePositive(Queue<Integer> q) { if (q.isEmpty()) return; else { int n = q.dequeue(); removePositive(q); if (n < 0) q.enqueue(n); } } publicstatic <E> E removeBottom(Stack<E> s) { if (s.size()==1) return s.pop(); else { E n = s.pop(); E bottom=removeBottom(s); s.push(n); return bottom; } }

7. publicstatic <E> void removeTowBottoms(Stack<E> s) { if (s.size()==2) { s.pop(); s.pop(); } else { E n = s.pop(); removeTowBottoms(s); s.push(n); } } publicstaticint totalOdd(Stack<Integer> s1) { int total; if (s1.isEmpty()) return 0; else { int n = s1.pop(); if (n % 2 == 1) total = n + totalOdd(s1); else total = totalOdd(s1); s1.push(n); return total; } }

8. publicstaticint totalEven(Stack<Integer> s1) { int total; if (s1.isEmpty()) return 0; else { int n = s1.pop(); if (n % 2 == 0) total = n + totalEven(s1); else total = totalEven(s1); s1.push(n); return total; } } publicstaticint totalTwoBottoms(Stack<Integer> s1) { int total; if (s1.isEmpty()) return 0; else { int n = s1.pop(); if (s1.size() <= 1) total = n + totalTwoBottoms(s1); else total = totalTwoBottoms(s1); s1.push(n); return total; } }

9. publicstaticint totalTwoStack(Stack<Integer> s1, Stack<Integer> s2) { if (s1.isEmpty()) return 0; else { int n1 = s1.pop(); int n2 = s2.pop(); int total = (n1 + n2) + totalTwoStack(s1, s2); s1.push(n1); s2.push(n2); return total; } } publicstatic <E> void swap(Stack<E> s1,Stack<E> s2) { if(s1.isEmpty()) return; else { E e1=s1.pop(); E e2=s2.pop(); swap(s1,s2); s1.push(e2); s2.push(e1); } }

10. publicstatic <E> void swapTowBottoms(Stack<E> s) { if (s.size()==2) { E e1=s.pop(); E e2=s.pop(); s.push(e1); s.push(e2); } else { E n = s.pop(); swapTowBottoms(s); s.push(n); } } publicstatic <E> void reverse(Queue<E> q) { if(q.isEmpty()) return; else { E e=q.dequeue(); reverse(q); q.enqueue(e); } }

11. publicstatic <E> boolean same(Queue<E> q1,Queue<E> q2) { if(q1.isEmpty()) returntrue; elseif(!q1.first().equals(q2.first())) { returnfalse; }else { E e1=q1.dequeue(); E e2=q2.dequeue(); boolean same=same(q1,q2); q1.enqueue(e1); q2.enqueue(e2); return same; } } OR publicstatic <E> boolean same(Queue<E> q1,Queue<E> q2) { if(q1.isEmpty()) returntrue; E e1=q1.dequeue(); E e2=q2.dequeue(); if(e1.equals(e2)) { boolean same=same(q1,q2); q1.enqueue(e1); q2.enqueue(e2); return same; }else { q1.enqueue(e1); q2.enqueue(e2); returnfalse; } }

12. publicstatic <E> int size(Stack<E> s) { if(s.isEmpty()) return 0; else { E e=s.pop(); int count= 1+size(s); s.push(e); return count; } }