public boolean hasNext() { return stack.size()>0; }
public boolean hasNext() { return stack.size()>0; }
private AmortizedPQueue(AmortizedPQueue<E> queue, E e) { /* Guarantee that there is always at least 1 element * in front, which makes peek worst-case O(1). */ if (queue.front.size() == 0) { this.front = queue.front.plus(e); this.back = queue.back; } else { this.front = queue.front; this.back = queue.back.plus(e); } }
private AmortizedPQueue(AmortizedPQueue<E> queue, E e) { /* Guarantee that there is always at least 1 element * in front, which makes peek worst-case O(1). */ if (queue.front.size() == 0) { this.front = queue.front.plus(e); this.back = queue.back; } else { this.front = queue.front; this.back = queue.back.plus(e); } }
public Entry<Integer,V> next() { IntTree<V> node = stack.get(0); final Entry<Integer,V> result = new SimpleImmutableEntry<Integer,V>(key, node.value); // find next node. // we've already done everything smaller, // so try least larger node: if(node.right.size>0) // we can descend to the right gotoMinOf(node.right); else // can't descend to the right -- try ascending to the right while (true) { // find current node's least larger ancestor, if any key -= node.key; // revert to parent's key stack = stack.subList(1); // climb up to parent // if parent was larger than child or there was no parent, we're done: if(node.key<0 || stack.size()==0) break; // otherwise parent was smaller -- try its parent: node = stack.get(0); } return result; }
public Entry<Integer,V> next() { IntTree<V> node = stack.get(0); final Entry<Integer,V> result = new SimpleImmutableEntry<Integer,V>(key, node.value); // find next node. // we've already done everything smaller, // so try least larger node: if(node.right.size>0) // we can descend to the right gotoMinOf(node.right); else // can't descend to the right -- try ascending to the right while (true) { // find current node's least larger ancestor, if any key -= node.key; // revert to parent's key stack = stack.subList(1); // climb up to parent // if parent was larger than child or there was no parent, we're done: if(node.key<0 || stack.size()==0) break; // otherwise parent was smaller -- try its parent: node = stack.get(0); } return result; }
Random r = new Random(); for(int i=0;i<1000;i++) { if(pstack.size()==0 || r.nextBoolean()) { // add if(r.nextBoolean()) { // append Integer v = r.nextInt(); int k = r.nextInt(pstack.size()+1); Integer v = r.nextInt(); if(k<pstack.size()) assertEquals(list.get(k), pstack.get(k)); int k = r.nextInt(pstack.size()); Integer v = r.nextInt(); list.set(k, v); int j = r.nextInt(pstack.size()), k=0; for(Integer e : pstack) { pstack = pstack.minus(s); assertEquals(list.size(), pstack.size()); UtilityTest.assertEqualsAndHash(list, pstack);
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> 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); } }
@Override public Streamable<T> next() { for(int i=0;i<increment && list.get().size()>0;i++) list.mutate(var -> var.minus(0)); for (int i = 0; list.get().size() < windowSize && it.hasNext(); i++) { if(it.hasNext()){ list.mutate(var -> var.plus(Math.max(0,var.size()),it.next())); } } return Streamable.fromIterable(list.get()); }
assertEqualsAndHash("plusAll should reverse order", stack3.subList(0,stack.size()), stack2); assertEqualsAndHash(stack3.minusAll(stack3), ConsPStack.empty()); assertEqualsAndHash(stack3.minusAll(stack), ConsPStack.empty());