@Test public void testRemove() { DoublyLinkedList<Integer> list = new DoublyLinkedList<Integer>(); ListNode2<Integer> node1 = list.add(1); list.remove(node1); node1 = list.add(1); ListNode2<Integer> node2 = list.add(2); list.remove(node1); assertEquals(1, list.size()); assertEquals(new Integer(2), list.first()); assertEquals(node2, list.head()); assertArrayEquals(new Integer[]{2}, list.toArray()); list.remove(node2); assertIsEmpty(list); node1 = list.add(1); node2 = list.add(2); list.remove(node2); assertEquals(1, list.size()); assertEquals(new Integer(1), list.first()); assertEquals(node1, list.head()); assertArrayEquals(new Integer[]{1}, list.toArray()); node2 = list.add(2); list.add(3); assertEquals(3, list.size()); assertArrayEquals(new Integer[]{1, 2, 3}, list.toArray()); list.remove(node2); assertEquals(2, list.size());
@Test public void testAddAfter() { DoublyLinkedList<Integer> list = new DoublyLinkedList<Integer>(); list.add(1); ListNode2<Integer> node2 = list.add(2); ListNode2<Integer> node4 = list.add(4); list.addAfter(node2, 3); assertEquals(4, list.size()); assertArrayEquals(new Integer[]{1, 2, 3, 4}, list.toArray()); ListNode2<Integer> node5 = list.addAfter(node4, 5); assertEquals(5, list.size()); assertArrayEquals(new Integer[]{1, 2, 3, 4, 5}, list.toArray()); assertEquals(new Integer(5), list.last()); assertEquals(node5, list.head()); }
@Test public void testEnqueue() { DoublyLinkedList<Integer> list = new DoublyLinkedList<Integer>(); list.enqueue(1); assertFalse(list.isEmpty()); assertEquals(1, list.size()); assertArrayEquals(new Integer[]{1}, list.toArray()); list.enqueue(2); assertFalse(list.isEmpty()); assertEquals(2, list.size()); assertArrayEquals(new Integer[]{2, 1}, list.toArray()); list.enqueue(3); assertFalse(list.isEmpty()); assertEquals(3, list.size()); assertArrayEquals(new Integer[]{3, 2, 1}, list.toArray()); assertEquals(new Integer(3), list.first()); assertEquals(new Integer(1), list.last()); }
@SuppressWarnings("unchecked") @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { this.bucketList = new DoublyLinkedList<Bucket>(); this.capacity = in.readInt(); int size = in.readInt(); this.counterMap = new HashMap<T, ListNode2<Counter<T>>>(size); Bucket currentBucket = null; ListNode2<Bucket> currentBucketNode = null; for (int i = 0; i < size; i++) { Counter<T> c = (Counter<T>) in.readObject(); if (currentBucket == null || c.count != currentBucket.count) { currentBucket = new Bucket(c.count); currentBucketNode = bucketList.add(currentBucket); } c.bucketNode = currentBucketNode; counterMap.put(c.item, currentBucket.counterList.add(c)); } }
@Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append('['); for (ListNode2<Bucket> bNode = bucketList.head(); bNode != null; bNode = bNode.getPrev()) { Bucket b = bNode.getValue(); sb.append('{'); sb.append(b.count); sb.append(":["); for (Counter<T> c : b.counterList) { sb.append('{'); sb.append(c.item); sb.append(':'); sb.append(c.error); sb.append("},"); } if (b.counterList.size() > 0) { sb.deleteCharAt(sb.length() - 1); } sb.append("]},"); } if (bucketList.size() > 0) { sb.deleteCharAt(sb.length() - 1); } sb.append(']'); return sb.toString(); }
bucket.counterList.remove(counterNode); // Detach count_i from Bucket_i's child-list counter.count = counter.count + incrementCount; bucketNext.counterList.add(counterNode); // Attach count_i to Bucket_i^+'s child-list break; } else if (counter.count > bucketNext.count) { bucketNext.counterList.add(counterNode); bucketNodeNext = bucketList.addAfter(bucketNodePrev, bucketNext); if (bucket.counterList.isEmpty()) // If Bucket_i's child-list is empty bucketList.remove(oldNode); // Detach Bucket_i from the Stream-Summary
@Test public void testAdd() { DoublyLinkedList<Integer> list = new DoublyLinkedList<Integer>(); list.add(1); assertFalse(list.isEmpty()); assertEquals(1, list.size()); assertArrayEquals(new Integer[]{1}, list.toArray()); list.add(2); assertFalse(list.isEmpty()); assertEquals(2, list.size()); assertArrayEquals(new Integer[]{1, 2}, list.toArray()); list.add(3); assertFalse(list.isEmpty()); assertEquals(3, list.size()); assertArrayEquals(new Integer[]{1, 2, 3}, list.toArray()); assertEquals(new Integer(1), list.first()); }
/** * @param item stream element (<i>e</i>) * @return Pair<isNewItem, itemDropped> where isNewItem is the return value of offer() and itemDropped is null if no item was dropped */ public Pair<Boolean, T> offerReturnAll(T item, int incrementCount) { ListNode2<Counter<T>> counterNode = counterMap.get(item); boolean isNewItem = (counterNode == null); T droppedItem = null; if (isNewItem) { if (size() < capacity) { counterNode = bucketList.enqueue(new Bucket(0)).getValue().counterList.add(new Counter<T>(bucketList.tail(), item)); } else { Bucket min = bucketList.first(); counterNode = min.counterList.tail(); Counter<T> counter = counterNode.getValue(); droppedItem = counter.item; counterMap.remove(droppedItem); counter.item = item; counter.error = min.count; } counterMap.put(item, counterNode); } incrementCounter(counterNode, incrementCount); return new Pair<Boolean, T>(isNewItem, droppedItem); }
/** * @param capacity maximum size (larger capacities improve accuracy) */ public StreamSummary(int capacity) { this.capacity = capacity; counterMap = new HashMap<T, ListNode2<Counter<T>>>(); bucketList = new DoublyLinkedList<Bucket>(); }
@Override public List<T> peek(int k) { List<T> topK = new ArrayList<T>(k); for (ListNode2<Bucket> bNode = bucketList.head(); bNode != null; bNode = bNode.getPrev()) { Bucket b = bNode.getValue(); for (Counter<T> c : b.counterList) { if (topK.size() == k) { return topK; } topK.add(c.item); } } return topK; }
@Override public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(this.capacity); out.writeInt(this.size()); for (ListNode2<Bucket> bNode = bucketList.tail(); bNode != null; bNode = bNode.getNext()) { Bucket b = bNode.getValue(); for (Counter<T> c : b.counterList) { out.writeObject(c); } } }
public ListNode2<T> addAfter(ListNode2<T> node, T value) { ListNode2<T> newNode = new ListNode2<T>(value); addAfter(node, newNode); return newNode; }
public void insertBefore(int pos, DoublyLinkedList l) { checkOutOfBounds(pos); Node ptr = start; if (pos == 1) { l.end.setLinkNext(start); start.setLinkPrev(l.end); start=l.start; size=size()+l.size(); } else { for (int i = 2; i <= size; i++) { if(i==pos){ Node tmp=ptr; ptr.setLinkPrev(l.end); l.end.setLinkNext(ptr.getLinkNext()); tmp.setLinkNext(l.start); l.start.setLinkPrev(tmp); size=size()+l.size(); break; } ptr=ptr.getLinkNext(); } } }
public static <T> StreamSummary<T> read(Kryo kryo, Input input) { int capacity = input.readInt(); int size = input.readInt(); StreamSummary<T> deser = new StreamSummary<>(capacity); StreamSummary<T>.Bucket currentBucket = null; ListNode2<StreamSummary<T>.Bucket> currentBucketNode = null; for (int i = 0; i < size; i++) { @SuppressWarnings("unchecked") Counter<T> c = (Counter<T>)kryo.readObject(input, Counter.class); if (currentBucket == null || c.count != currentBucket.count) { currentBucket = deser.new Bucket(c.count); currentBucketNode = deser.bucketList.add(currentBucket); } c.bucketNode = currentBucketNode; deser.counterMap.put(c.item, currentBucket.counterList.add(c)); } return deser; } }
@Test public void testAddNode() { DoublyLinkedList<Integer> list = new DoublyLinkedList<Integer>(); list.add(new ListNode2<Integer>(1)); assertFalse(list.isEmpty()); assertEquals(1, list.size()); assertArrayEquals(new Integer[]{1}, list.toArray()); list.add(new ListNode2<Integer>(2)); assertFalse(list.isEmpty()); assertEquals(2, list.size()); assertArrayEquals(new Integer[]{1, 2}, list.toArray()); list.add(new ListNode2<Integer>(3)); assertFalse(list.isEmpty()); assertEquals(3, list.size()); assertArrayEquals(new Integer[]{1, 2, 3}, list.toArray()); assertEquals(new Integer(1), list.first()); }
/** * @param item stream element (<i>e</i>) * @return Pair<isNewItem, itemDropped> where isNewItem is the return value of offer() and itemDropped is null if no item was dropped */ public Pair<Boolean, T> offerReturnAll(T item, int incrementCount) { ListNode2<Counter<T>> counterNode = counterMap.get(item); boolean isNewItem = (counterNode == null); T droppedItem = null; if (isNewItem) { if (size() < capacity) { counterNode = bucketList.enqueue(new Bucket(0)).getValue().counterList.add(new Counter<T>(bucketList.tail(), item)); } else { Bucket min = bucketList.first(); counterNode = min.counterList.tail(); Counter<T> counter = counterNode.getValue(); droppedItem = counter.item; counterMap.remove(droppedItem); counter.item = item; counter.error = min.count; } counterMap.put(item, counterNode); } incrementCounter(counterNode, incrementCount); return new Pair<Boolean, T>(isNewItem, droppedItem); }
bucket.counterList.remove(counterNode); // Detach count_i from Bucket_i's child-list counter.count = counter.count + incrementCount; bucketNext.counterList.add(counterNode); // Attach count_i to Bucket_i^+'s child-list break; } else if (counter.count > bucketNext.count) { bucketNext.counterList.add(counterNode); bucketNodeNext = bucketList.addAfter(bucketNodePrev, bucketNext); if (bucket.counterList.isEmpty()) // If Bucket_i's child-list is empty bucketList.remove(oldNode); // Detach Bucket_i from the Stream-Summary
@Test(expected = ConcurrentModificationException.class) public void testConcurrentModification() { DoublyLinkedList<Integer> list = new DoublyLinkedList<Integer>(); list.add(1); list.add(2); list.add(3); for (int i : list) { if (i == 2) { list.add(4); } } }
@Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append('['); for (ListNode2<Bucket> bNode = bucketList.head(); bNode != null; bNode = bNode.getPrev()) { Bucket b = bNode.getValue(); sb.append('{'); sb.append(b.count); sb.append(":["); for (Counter<T> c : b.counterList) { sb.append('{'); sb.append(c.item); sb.append(':'); sb.append(c.error); sb.append("},"); } if (b.counterList.size() > 0) { sb.deleteCharAt(sb.length() - 1); } sb.append("]},"); } if (bucketList.size() > 0) { sb.deleteCharAt(sb.length() - 1); } sb.append(']'); return sb.toString(); }