@Test public void Deque_addLast_AddsTwo() { deque.addLast("firstString"); deque.addLast("secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 2); }
/** * @param instanceFrame instance frame * @return iterable over instance members of the frame, including those nested in namespaces */ public static Iterable<? extends INamedElement> instanceMembers( final IInstanceFrame instanceFrame) { final List<INamedElement> members = new ArrayList<>(); // Iterate over the member functions of the frame, including those nested in namespaces. final Deque<INamedElement> queue = new LinkedList<>(); queue.addLast(instanceFrame); while (!queue.isEmpty()) { final INamedElement cur = queue.getFirst(); queue.removeFirst(); final INamedElementContainer contCur = (INamedElementContainer) cur; for (final INamedElement member : contCur.members()) if (Ast.membership(member) == (contCur == instanceFrame ? ScopeMembership.InstanceMember : ScopeMembership.StaticMember)) { members.add(member); if (member instanceof INamedElementContainer) { // Tail-recursively treat this nested namespace. queue.addLast(member); } } } return members; }
// Method 2: BFS Solution public boolean validTreeII(int n, int[][] edges) { int[] visited = new int[n]; List<List<Integer>> adjList = new ArrayList<>(); for (int i = 0; i < n; ++i) { adjList.add(new ArrayList<Integer>()); } for (int[] edge : edges) { adjList.get(edge[0]).add(edge[1]); adjList.get(edge[1]).add(edge[0]); } Deque<Integer> q = new LinkedList<Integer>(); q.addLast(0); visited[0] = 1; // vertex 0 is in the queue, being visited while (!q.isEmpty()) { Integer cur = q.removeFirst(); for (Integer succ : adjList.get(cur)) { if (visited[succ] == 1) { return false; } // loop detected if (visited[succ] == 0) { q.addLast(succ); visited[succ] = 1; } } visited[cur] = 2; // visit completed } for (int v : visited) { if (v == 0) { return false; } } // # of connected components is not 1 return true; }
public static void main(String[] args) { Deque<Integer> ints = new Deque<Integer>(); assert ints.size() == 0; assert ints.isEmpty(); ints.addFirst(1); assert ints.size() == 1; assert !ints.isEmpty(); int val = ints.removeFirst(); assert val == 1; assert ints.size() == 0; assert ints.isEmpty(); ints.addFirst(2); assert ints.size() == 1; assert !ints.isEmpty(); val = ints.removeLast(); assert val == 2; assert ints.size() == 0; assert ints.isEmpty(); ints.addFirst(3); ints.addFirst(2); ints.addFirst(1); ints.addLast(4); ints.addLast(5); ints.addLast(6); assert ints.size() == 6; assert !ints.isEmpty(); for (int value : ints) { StdOut.print(value + " "); } StdOut.println(); while (!ints.isEmpty()) { StdOut.println(ints.removeLast()); } assert ints.size() == 0; assert ints.isEmpty(); for (int i = 0; i < 10; ++i) { ints.addFirst(i); } for (int i = 0; i < 10; ++i) { assert ints.size() == 10 - i; ints.removeLast(); } assert ints.size() == 0; }
public static boolean bfsIterative(TreeNode root, int val) { Deque<TreeNode> s = new LinkedList<>(); s.push(root); while (!s.isEmpty()) { TreeNode curr = s.removeFirst(); if (curr.left != null) s.addLast(curr.left); if (curr.right != null) s.addLast(curr.right); if (curr.value == val) return true; } return false; }
@Test public void testAddLastAndRemoveLastAll() { deque.addLast("1"); deque.addLast("2"); deque.addLast("3"); deque.addLast("4"); assertEquals(deque.removeLast(), "4"); assertEquals(deque.removeLast(), "3"); assertEquals(deque.removeLast(), "2"); assertEquals(deque.removeLast(), "1"); }
@Test public void Deque_addLast_removeLast_AddsRemovesTwo() { deque.addLast("firstString"); deque.addLast("secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 2); String returnedString = deque.removeLast(); assertEquals(returnedString, "secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 1); returnedString = deque.removeLast(); assertEquals(returnedString, "firstString"); assertTrue(deque.isEmpty()); assertEquals(deque.size(), 0); }
private List<List<Integer>> help1(TreeNode root) { List<List<Integer>> res = new ArrayList<List<Integer>>(); if (root == null) { return res; } Deque<TreeNode> current = new LinkedList<>(); Deque<TreeNode> next = new LinkedList<>(); boolean isOdd = true; current.add(root); while (!current.isEmpty()) { int size = current.size(); List<Integer> level = new LinkedList<Integer>(); if (isOdd) { for (int i = 0; i < size; i++) { TreeNode top = current.removeFirst(); level.add(top.val); if (top.left != null) { next.addLast(top.left); } if (top.right != null) { next.addLast(top.right); } } } else { for (int i = 0; i < size; i++) { TreeNode top = current.removeLast(); level.add(top.val); if (top.right != null) { next.addFirst(top.right); } if (top.left != null) { next.addFirst(top.left); } } } isOdd = !isOdd; current = next; res.add(level); } return res; }
@Test public void testIsEmpty() { Deque<String> deque = new Deque<String>(); assertTrue(deque.isEmpty()); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); deque.addLast(new String("test last")); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); assertFalse(deque.isEmpty()); deque.removeFirst(); deque.removeFirst(); deque.removeFirst(); deque.removeLast(); deque.removeLast(); assertTrue(deque.isEmpty()); }
@Test public void testOneEmptyOne() { deque.addFirst("1"); assertEquals(deque.removeFirst(), "1"); deque.addLast("2"); }
public List<String> removeInvalidParentheses(String s) { // 由于是去掉最少的括号,所以以去掉括号的个数为BFS的层数.通过记录的方式减少不必要的访问(重复的访问子树),缩短时间的关键是备忘memorized // 标记在某一level是否已经找到一个合法的string,且其值表示在哪一level找到 int flag = -1; // 全局hashset,用作去重 Set<String> gset = new HashSet<String>(); Set<String> output = new HashSet<String>(); // 初始化BFS的队列Q Deque<Node> q = new ArrayDeque<Node>(); Node root = new Node(s, 0); q.addLast(root); while (!q.isEmpty()) { Node u = q.removeFirst(); String subs = u.s; // 说明已经找到全部,返回结果即可,这里很巧妙 if ((u.depth == (flag + 1)) && flag != -1) { break; } if (checkValid(subs) == 0) { // 说明合法,结束本次循环,并不检测深一层的子树,但要检测完同一level的所有节点 if (flag == -1) flag = u.depth; output.add(subs); continue; } else { // u.s无效,分两种情况讨论:a.flag==-1,说明还没找到合适的,所以要将子树都填加 b.flag!=-1,说明在该level已经找到,不必再添加子树 if (flag != -1) { continue; } else { for (int i = 0; i < subs.length(); i++) { StringBuilder sb = new StringBuilder(subs); sb.deleteCharAt(i); String ssubs = sb.toString(); if (!gset.contains(ssubs)) { gset.add(ssubs); Node n = new Node(ssubs, u.depth + 1); q.addLast(n); } } } } } return new ArrayList<String>(output); }
/** * @param fn function * @return eventual overrides of the function, unifying those differing only in generic derivation */ public static Iterable<? extends IFunction> eventualOverrides(final IFunction fn) { // Iterate over the eventually overridden functions, // unifying those differing only through generic derivation. final Set<IFunction> processedEO = new LinkedHashSet<>(); final Deque<IFunction> queueEO = new LinkedList<>(); queueEO.addLast(fn); while (!queueEO.isEmpty()) { final IFunction fnEO = queueEO.getFirst(); queueEO.removeFirst(); if (!processedEO.contains(fnEO)) { processedEO.add(fnEO); // Tail-recurse on the function's direct overrides. for (final ResolvedName directOverride : fnEO.directOverrides()) queueEO.addLast((IFunction) directOverride.namedElement()); } } return processedEO; }
@Test public void testAddition() { Deque<String> deque = new Deque<String>(); deque.addFirst(new String("test")); assertFalse(deque.isEmpty()); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); assertEquals(deque.size(), 3); }
@Test public void testAddLastAndAddFirstWithRemoveLast() { deque.addLast("4"); deque.addLast("5"); deque.addLast("6"); deque.addLast("7"); deque.addFirst("3"); deque.addFirst("2"); deque.addFirst("1"); assertEquals(deque.removeLast(), "7"); assertEquals(deque.removeLast(), "6"); assertEquals(deque.removeLast(), "5"); assertEquals(deque.removeLast(), "4"); assertEquals(deque.removeLast(), "3"); assertEquals(deque.removeLast(), "2"); assertEquals(deque.removeLast(), "1"); }
@Test(expected = UnsupportedOperationException.class) public void testRemoveFromIterator() { Deque<String> deque = new Deque<String>(); deque.addFirst("middle"); deque.addLast("last"); deque.addFirst("first"); Iterator<String> i = deque.iterator(); i.next(); i.remove(); // should throw exception }
@Test(expected = NoSuchElementException.class) public void testNextFromEmptyIterator() { Deque<String> deque = new Deque<String>(); deque.addLast("last"); deque.addFirst("first"); Iterator<String> i = deque.iterator(); i.next(); i.next(); i.next(); // should throw exception }
@Test public void testAdditionReverseOrdered() { Deque<Integer> deque = new Deque<Integer>(); for (int i = 0; i < 10; i++) { deque.addLast(i); } for (int i = 0; i < 10; i++) { assertEquals(deque.removeFirst(), new Integer(i)); } }
@Test public void Deque_iterator_iterates() { deque.addFirst("firstString"); deque.addFirst("secondString"); deque.addLast("thirdString"); Iterator<String> dequeIterator = deque.iterator(); assertEquals(dequeIterator.next(), "secondString"); assertEquals(dequeIterator.next(), "firstString"); assertEquals(dequeIterator.next(), "thirdString"); }
public boolean getNextBlock() throws IOException { if (curRangeIndex < 0 || curRangeIndex >= indexes.size()) return false; /* seek to the correct offset to the data, and calculate the data size */ IndexHelper.IndexInfo curColPosition = indexes.get(curRangeIndex); /* see if this read is really necessary. */ if (reversed) { if ((finishColumn.length > 0 && comparator.compare(finishColumn, curColPosition.lastName) > 0) || (startColumn.length > 0 && comparator.compare(startColumn, curColPosition.firstName) < 0)) return false; } else { if ((startColumn.length > 0 && comparator.compare(startColumn, curColPosition.lastName) > 0) || (finishColumn.length > 0 && comparator.compare(finishColumn, curColPosition.firstName) < 0)) return false; } boolean outOfBounds = false; // seek to current block // curIndexInfo.offset is the relative offset from the first block file.seek(firstBlockPos + curColPosition.offset); // read all columns of current block into memory! DataInputStream blockIn = ColumnFamily.serializer() .getBlockInputStream(file, curColPosition.sizeOnDisk, compressContext); try { int size = 0; while ((size < curColPosition.width) && !outOfBounds) { IColumn column = emptyColumnFamily.getColumnSerializer().deserialize(blockIn); size += column.serializedSize(); if (reversed) blockColumns.addFirst(column); else blockColumns.addLast(column); /* see if we can stop seeking. */ if (!reversed && finishColumn.length > 0) outOfBounds = comparator.compare(column.name(), finishColumn) >= 0; else if (reversed && startColumn.length > 0) outOfBounds = comparator.compare(column.name(), startColumn) >= 0; if (outOfBounds) break; } } catch (IOException e) { logger.error(e.toString()); throw e; } finally { ColumnFamily.serializer().releaseBlockInputStream(blockIn, compressContext); } if (reversed) curRangeIndex--; else curRangeIndex++; return true; }
@Test(expected = NoSuchElementException.class) public void testRemoveLastFromEmptyDeque() { Deque<Integer> deque = new Deque<Integer>(); int count = 10; for (int i = 0; i < count; i++) { deque.addLast(i); } for (int i = 0; i < count; i++) { deque.removeLast(); } deque.removeLast(); // should throw }
@Test public void testRemove() { Deque<String> deque = new Deque<String>(); deque.addFirst(new String("test")); deque.addFirst(new String("test first")); deque.addLast(new String("test last")); deque.removeLast(); deque.removeFirst(); assertTrue(deque.size() == 1); deque.removeLast(); assertTrue(deque.size() == 0); }
public static void main(String[] args) { Deque<String> myDeque = new Deque<String>(); String[] str = new String[] {"Jrui", "Long", "Jason"}; myDeque.addFirst(str[0]); myDeque.addLast(str[2]); myDeque.addFirst(str[1]); Iterator<String> test = myDeque.iterator(); while (test.hasNext()) { String s = test.next(); StdOut.println(s); } }
public int[] maxSlidingWindow(int[] nums, int k) { if (nums == null || nums.length == 0) return new int[0]; int[] result = new int[nums.length + 1 - k]; Deque<Integer> dq = new LinkedList<Integer>(); for (int i = 0, j = 1 - k; i < nums.length; i++, j++) { if (!dq.isEmpty() && dq.peekFirst() <= i - k) dq.removeFirst(); while (!dq.isEmpty() && nums[dq.peekLast()] <= nums[i]) dq.removeLast(); dq.addLast(i); if (j >= 0) result[j] = nums[dq.peekFirst()]; } return result; }
public static void main(String[] args) { Deque<String> d = new Deque<String>(); d.addFirst("1"); d.addFirst("2"); d.addFirst("3"); d.addLast("7"); d.removeFirst(); d.removeFirst(); for (String s : d) { System.out.println(s); } }
public static void main(String[] args) { // unit testing Deque<String> d = new Deque<String>(); d.addFirst("sant"); d.addLast("prakash"); d.addFirst("sid"); for (String s : d) StdOut.println(s); StdOut.println("removing last"); StdOut.println(d.removeLast()); StdOut.println("resulting list"); for (String s : d) StdOut.println(s); StdOut.println("removing fist"); StdOut.println(d.removeFirst()); StdOut.println("resulting list"); for (String s : d) StdOut.println(s); }
@Test public void test10() { deque = new Deque<String>(); deque.addFirst("1"); deque.addFirst("2"); deque.addFirst("3"); deque.addFirst("4"); assertEquals(deque.removeLast(), "1"); assertEquals(deque.removeFirst(), "4"); deque.addLast("7"); assertEquals(deque.removeLast(), "7"); assertEquals(deque.removeLast(), "2"); assertEquals(deque.removeLast(), "3"); assertEquals(deque.size(), 0); }
public boolean getNextBlock() throws IOException { if (curRangeIndex < 0 || curRangeIndex >= indexes.size()) return false; /* seek to the correct offset to the data, and calculate the data size */ IndexHelper.IndexInfo curColPosition = indexes.get(curRangeIndex); /* see if this read is really necessary. */ if (reversed) { if ((finishColumn.length > 0 && comparator.compare(finishColumn, curColPosition.lastName) > 0) || (startColumn.length > 0 && comparator.compare(startColumn, curColPosition.firstName) < 0)) return false; } else { if ((startColumn.length > 0 && comparator.compare(startColumn, curColPosition.lastName) > 0) || (finishColumn.length > 0 && comparator.compare(finishColumn, curColPosition.firstName) < 0)) return false; } boolean outOfBounds = false; file.reset(); long curOffset = file.skipBytes((int) curColPosition.offset); assert curOffset == curColPosition.offset; while (file.bytesPastMark() < curColPosition.offset + curColPosition.width && !outOfBounds) { IColumn column = emptyColumnFamily.getColumnSerializer().deserialize(file); if (reversed) blockColumns.addFirst(column); else blockColumns.addLast(column); /* see if we can stop seeking. */ if (!reversed && finishColumn.length > 0) outOfBounds = comparator.compare(column.name(), finishColumn) >= 0; else if (reversed && startColumn.length > 0) outOfBounds = comparator.compare(column.name(), startColumn) >= 0; if (outOfBounds) break; } if (reversed) curRangeIndex--; else curRangeIndex++; return true; }
@Test public void Deque_addLast_AddsOne() { deque.addLast("firstString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 1); }
@Test(expected = NullPointerException.class) public void testAddNullLastNullPointerException() { Deque<String> deque = new Deque<String>(); deque.addLast(null); }
static void fillTest(Deque<Integer> deque) { for (int i = 20; i < 27; i++) deque.addFirst(i); for (int i = 50; i < 55; i++) deque.addLast(i); }