public static <E> PQueue<E> queue() { return AmortizedPQueue.empty(); }
public static void main(String[] args) { AmortizedPQueue<Integer> queue = new AmortizedPQueue<Integer>(); queue = queue.plus(1).minus().minus().plus(2).plus(3).plus(4).plus(5).minus().plus(6).plus(7); PQueue<Integer> original = queue; System.out.println(" \t" + queue.front + " " + queue.back); while(queue.size() > 0) { int i = queue.peek(); queue = queue.minus(); System.out.println(i + " <- \t" + queue.front + " " + queue.back); } System.out.println(original); } }
public AmortizedPQueue<E> minus() { if (size() == 0) { return this; } int fsize = front.size(); if (fsize == 0) { //If there's nothing on front, dump back onto front //(as stacks, this goes in reverse like we want) //and take one off. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()).minus(); } else if (fsize == 1) { //If there's one element on front, dump back onto front, //but now we've already removed the head. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()); } else { //If there's more than one on front, we pop one off. return new AmortizedPQueue<E>(front.minus(0), back); } }
public void testSerializationForAmortizedPQueue() { final AmortizedPQueue<String> initialPQueue = AmortizedPQueue.<String> empty() .plus(ELEMENT1) .plus(ELEMENT2) .plus(ELEMENT3); final byte[] serializedPQueue = serializeToByteArray(initialPQueue); assertNotNull(serializedPQueue); assertTrue(serializedPQueue.length > 0); @SuppressWarnings("unchecked") final AmortizedPQueue<String> deserializedPQueue = deserializeFromByteArray(serializedPQueue, AmortizedPQueue.class); assertNotNull(deserializedPQueue); assertEquals(3, deserializedPQueue.size()); assertNotSame(initialPQueue, deserializedPQueue); Object[] deserializedElements = deserializedPQueue.toArray(); assertEquals(ELEMENT1, deserializedElements[0]); assertEquals(ELEMENT2, deserializedElements[1]); assertEquals(ELEMENT3, deserializedElements[2]); }
public AmortizedPQueue<E> plusAll(Collection<? extends E> list) { AmortizedPQueue<E> result = this; for(E e : list) { result = result.plus(e); } return result; }
public E peek() { if(size()==0) return null; return front.get(0); }
public AmortizedPQueue<E> plus(E e) { return new AmortizedPQueue<E>(this, e); }
public AmortizedPQueue<E> minus() { if (size() == 0) { return this; } int fsize = front.size(); if (fsize == 0) { //If there's nothing on front, dump back onto front //(as stacks, this goes in reverse like we want) //and take one off. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()).minus(); } else if (fsize == 1) { //If there's one element on front, dump back onto front, //but now we've already removed the head. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()); } else { //If there's more than one on front, we pop one off. return new AmortizedPQueue<E>(front.minus(0), back); } }
public AmortizedPQueue<E> plusAll(Collection<? extends E> list) { AmortizedPQueue<E> result = this; for(E e : list) { result = result.plus(e); } return result; }
public E peek() { if(size()==0) return null; return front.get(0); }
public AmortizedPQueue<E> plus(E e) { return new AmortizedPQueue<E>(this, e); }
public static void main(String[] args) { AmortizedPQueue<Integer> queue = new AmortizedPQueue<Integer>(); queue = queue.plus(1).minus().minus().plus(2).plus(3).plus(4).plus(5).minus().plus(6).plus(7); PQueue<Integer> original = queue; System.out.println(" \t" + queue.front + " " + queue.back); while(queue.size() > 0) { int i = queue.peek(); queue = queue.minus(); System.out.println(i + " <- \t" + queue.front + " " + queue.back); } System.out.println(original); } }
public static <E> PQueue<E> queue() { return AmortizedPQueue.empty(); }
public AmortizedPQueue<E> minus() { if (size() == 0) { return this; } int fsize = front.size(); if (fsize == 0) { //If there's nothing on front, dump back onto front //(as stacks, this goes in reverse like we want) //and take one off. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()).minus(); } else if (fsize == 1) { //If there's one element on front, dump back onto front, //but now we've already removed the head. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()); } else { //If there's more than one on front, we pop one off. return new AmortizedPQueue<E>(front.minus(0), back); } }
public AmortizedPQueue<E> plusAll(Collection<? extends E> list) { AmortizedPQueue<E> result = this; for(E e : list) { result = result.plus(e); } return result; }
public E peek() { if(size()==0) return null; return front.get(0); }
public AmortizedPQueue<E> plus(E e) { return new AmortizedPQueue<E>(this, e); }
public static void main(String[] args) { AmortizedPQueue<Integer> queue = new AmortizedPQueue<Integer>(); queue = queue.plus(1).minus().minus().plus(2).plus(3).plus(4).plus(5).minus().plus(6).plus(7); PQueue<Integer> original = queue; System.out.println(" \t" + queue.front + " " + queue.back); while(queue.size() > 0) { int i = queue.peek(); queue = queue.minus(); System.out.println(i + " <- \t" + queue.front + " " + queue.back); } System.out.println(original); } }
public static <E> PQueue<E> queue() { return AmortizedPQueue.empty(); }
public AmortizedPQueue<E> minus() { if (size() == 0) return this; int fsize = front.size(); if (fsize == 0) { //If there's nothing on front, dump back onto front //(as stacks, this goes in reverse like we want) //and take one off. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()).minus(); } else if (fsize == 1) { //If there's one element on front, dump back onto front, //but now we've already removed the head. return new AmortizedPQueue<E>(Empty.<E>stack().plusAll(back), Empty.<E>stack()); } else { //If there's more than one on front, we pop one off. return new AmortizedPQueue<E>(front.minus(0), back); } }