Question

Using any variable and any name for the methods (data structure java eclipse)

1) Find odd average and even number average in a linked list using recursion

2) Remove duplicate from a stack.

Answer 1

1) Find odd average and even number average in a linked list using recursion

// A linked list node
class Node
{
   int data;
   Node next;

   Node(int data, Node next) {
       this.data = data;
       this.next = next;
   }

   Node() { }
};

class ListUtils
{
   // Helper function to print given linked list
   public static void printList(Node head)
   {
       Node ptr = head;
       while (ptr != null)
       {
           System.out.print(ptr.data + " -> ");
           ptr = ptr.next;
       }

       System.out.println("null");
   }

   // Recursive function to rearrange the list
   public static Node rearrange(Node head, Node odd, Node even,
                               Node oddRef)
   {
       // we have reached the end of the list
       if (head == null)
       {
           // null terminate the list
           odd.next = null;

           // join even sublist and odd sublist
           even.next = oddRef.next;
           return head;
       }

       // if current node is odd
       if ((head.data & 1) != 0)
       {
           odd.next = head;
           rearrange(head.next, head, even, oddRef);
       }

       // if current node is even
       else
       {
           even.next = head;
           rearrange(head.next, odd, head, oddRef);
       }

       return head;
   }

   // Rearrange the given linked list by separating odd nodes
   // from even ones and maintaining their relative order.
   public static Node rearrangeEvenOdd(Node head)
   {
       Node odd = new Node();
       Node even = new Node();

       rearrange(head, odd, even, odd);

       return even.next;
   }

   public static void main(String[] args)
   {
       // input keys
       int[] keys = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

       Node head = null;
       for (int i = keys.length - 1; i >= 0; i--) {
           head = new Node(keys[i], head);
       }

       head = rearrangeEvenOdd(head);
       printList(head);
   }
}

2) Remove duplicate from a stack.

import java.util.*;

/**
* @author Daniel Pitts
*/
public class UniqueQueue<T> implements Queue<T>, Set<T> {
private final Set<T> data = new LinkedHashSet<T>();

public int size() {
return data.size();
}

public boolean isEmpty() {
return data.isEmpty();
}

public boolean contains(Object o) {
return data.contains(o);
}

public Iterator<T> iterator() {
return data.iterator();
}

public Object[] toArray() {
return data.toArray();
}

public <T> T[] toArray(T[] a) {
return data.toArray(a);
}

public boolean add(T t) {
return data.add(t);
}

public boolean offer(T t) {
return add(t);
}

public T remove() {
final Iterator<T> iterator = data.iterator();
T t = iterator.next();
iterator.remove();
return t;
}

public T poll() {
final Iterator<T> iterator = data.iterator();
if (iterator.hasNext()) {
T t = iterator.next();
iterator.remove();
return t;
}
return null;
}

public T element() {
return data.iterator().next();
}

public T peek() {
final Iterator<T> iterator = data.iterator();
if (iterator.hasNext()) {
return iterator.next();
}
return null;
}

public boolean remove(Object o) {
return data.remove(o);
}

public boolean containsAll(Collection<?> c) {
return data.containsAll(c);
}

public boolean addAll(Collection<? extends T> c) {
return data.addAll(c);
}

public boolean retainAll(Collection<?> c) {
return data.retainAll(c);
}

public boolean removeAll(Collection<?> c) {
return data.removeAll(c);
}

public void clear() {
data.clear();
}

public boolean equals(Object o) {
return data.equals(o);
}

public int hashCode() {
return data.hashCode();
}
}