@Test public void Deque_addLast_AddsTwo() { deque.addLast("firstString"); deque.addLast("secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 2); }
@Override public Path search(Integer source, Integer target) { check(source, target); Deque<Integer> queue = new ArrayDeque<>(graph.size()); Map<Integer, Integer> parents = new HashMap<>(graph.size()); queue.addLast(source); parents.put(source, null); while (!queue.isEmpty()) { Integer current = queue.removeFirst(); if (current.equals(target)) { return tracebackPath(target, parents, graph); } for (Integer child : graph.getChildrenOf(current)) { if (!parents.containsKey(child)) { parents.put(child, current); queue.addLast(child); } } } return Path.emptyPath(); }
/** * @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; }
public int[] maxSlidingWindow(int[] nums, int k) { if (nums.length == 0 || k == 0) { return new int[] {}; } int[] result = new int[nums.length - k + 1]; PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>( k, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { if (o1 < o2) { return 1; } else if (o1 > o2) { return -1; } else { return 0; } } }); Deque<Integer> deque = new LinkedList<Integer>(); for (int i = 0; i < k; i++) { deque.addLast(nums[i]); priorityQueue.add(nums[i]); } for (int i = k; i < nums.length; i++) { result[i - k] = priorityQueue.peek(); int first = deque.removeFirst(); priorityQueue.remove(first); deque.addLast(nums[i]); priorityQueue.add(nums[i]); } result[result.length - 1] = priorityQueue.peek(); return result; }
private void buildForStatement(ForStatementTree tree) { Block falseBranch = currentBlock; // process step currentBlock = createBlock(); Block updateBlock = currentBlock; for (StatementTree updateTree : Lists.reverse(tree.update())) { build(updateTree); } continueTargets.addLast(currentBlock); // process body currentBlock = createBlock(currentBlock); breakTargets.addLast(falseBranch); build(tree.statement()); breakTargets.removeLast(); continueTargets.removeLast(); Block body = currentBlock; // process condition ExpressionTree condition = tree.condition(); if (condition != null) { currentBlock = createBranch(tree, body, falseBranch); buildCondition(condition, body, falseBranch); } else { currentBlock = createUnconditionalJump(tree, body); } updateBlock.successors.add(currentBlock); // process init currentBlock = createBlock(currentBlock); for (StatementTree init : Lists.reverse(tree.initializer())) { build(init); } }
// 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; }
protected void visitBlobsField(T state, Field field) throws PropertyException { Type type = field.getType(); if (type.isSimpleType()) { // scalar } else if (type.isComplexType()) { // complex property String name = field.getName().getPrefixedName(); T childState = getChild(state, name, type); if (childState != null) { path.addLast(name); visitBlobsComplex(childState, (ComplexType) type); path.removeLast(); } } else { // array or list Type fieldType = ((ListType) type).getFieldType(); if (fieldType.isSimpleType()) { // array } else { // complex list String name = field.getName().getPrefixedName(); path.addLast(name); int i = 0; for (T childState : getChildAsList(state, name)) { path.addLast(String.valueOf(i++)); visitBlobsComplex(childState, (ComplexType) fieldType); path.removeLast(); } path.removeLast(); } } }
public int BFS(int end) { Deque<Vertice> q = new ArrayDeque(); Set closed = new HashSet(); Vertice initialVertice = cache.get(1); q.addLast(initialVertice); closed.add(initialVertice); while (!q.isEmpty()) { Vertice tmp = q.pollFirst(); if (inverseCache.get(tmp) == end) return inverseCache.get(tmp); for (int x = 0; x < tmp.neighbours.size(); x++) { Vertice o = tmp.neighbours.get(x); if (!closed.contains(o)) { closed.add(o); q.addLast(o); } } } return 0; }
/** * Queue it up in the {@link ReplayEntry#m_blockedMessages} queue before the {@link * CompleteTransactionMessage} for this entry's transaction is received. Otherwise add it * straight to the {@link ReplayEntry#m_sequencedMessages} queue. * * @param m an SP invocation message */ void addBlockedMessage(VoltMessage m) { if (m_lastFragment == null) { m_blockedMessages.addLast(m); } else { m_sequencedMessages.addLast(m); } }
private void buildSwitchStatement(SwitchStatementTree tree) { // FIXME useless node created for default cases. SwitchStatementTree switchStatementTree = tree; Block switchSuccessor = currentBlock; // process condition currentBlock = createBlock(); currentBlock.terminator = switchStatementTree; switches.addLast(currentBlock); build(switchStatementTree.expression()); // process body currentBlock = createBlock(switchSuccessor); breakTargets.addLast(switchSuccessor); if (!switchStatementTree.cases().isEmpty()) { CaseGroupTree firstCase = switchStatementTree.cases().get(0); for (CaseGroupTree caseGroupTree : Lists.reverse(switchStatementTree.cases())) { build(caseGroupTree.body()); switches.getLast().successors.add(currentBlock); if (!caseGroupTree.equals(firstCase)) { // No block predecessing the first case group. currentBlock = createBlock(currentBlock); } } } breakTargets.removeLast(); // process condition currentBlock = switches.removeLast(); }
@Override public void startElement(String uri, String localName, String qName, Attributes attributes) { elementStack.addLast(localName); elementContentStack.addLast(new StringBuilder()); if (path(rootPath)) { currentText = new Text(); } }
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; }
/** * Overloaded method to add a new operand to the Node Equation * * @param operand * @throws InvalidEquationException * @throws InvalidOperandException */ public void add(String inputOperand) throws InvalidEquationException, InvalidOperandException { // Check if this operand can be added at this state of equation Object equationEndElement = equation.peekLast(); if (equationEndElement instanceof Operand) { logs.trace("Attempting to insert an operand after another operand"); throw new InvalidEquationException("Operand can not be inserted after " + "another operator"); } equation.addLast(new Operand(inputOperand)); equation.addLast(""); }
private static void add(float x, float y) { Deque<Vector2f> tmp = new ArrayDeque<Vector2f>(); while (!graphRes.isEmpty() && graphRes.getFirst().x < x) { tmp.addLast(graphRes.pollFirst()); } tmp.addLast(new Vector2f(x, y)); while (!graphRes.isEmpty()) { tmp.addLast(graphRes.pollFirst()); } graphRes = tmp; while (y / graph1dY > height) { frame.jSliderdY1.setValue(frame.jSliderdY1.getValue() + 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 void cycleKeyList(Object key) { keyList.addLast(key); if (keyList.size() > size) { Object oldestKey = keyList.removeFirst(); delegate.removeObject(oldestKey); } }
public ExchangeMetrics addContext(MetricsContext ctx) { contexts.addLast(ctx); if (started) { ctx.start(exchange); } return this; }
private void updateEstimates(int secondsRemaining) { // Archivo.logger.debug("Adding {} to estimates", secondsRemaining); recentEndTimeEstimates.addLast(secondsRemaining); if (recentEndTimeEstimates.size() > MAX_END_TIME_ESTIMATES) { recentEndTimeEstimates.removeFirst(); } }
@Override public WebSocketSession getSession(Deque<SessionContext> sessionContexts) { // Remove the first item, and add at the end SessionContext s = sessionContexts.removeFirst(); sessionContexts.addLast(s); return s.getSession(); }
private static void deepVisitInternal( Object o, Predicate<Field> fieldPredicate, List<Object> visited, Deque<Object> refChain, Visitor visitor) throws IllegalArgumentException, IllegalAccessException { Class<?> clazz = (o != null) ? o.getClass() : null; refChain.addLast(o); Iterable<Object> filteredRefChain = Iterables.filter(refChain, Predicates.not(Predicates.instanceOf(Dumpers.Entry.class))); try { if (o == null) { // no-op } else if (isClassUntraversable(clazz)) { visitor.visit(o, filteredRefChain); } else if (containsSame(visited, o)) { // no-op } else { visited.add(o); boolean subTreeComplete = visitor.visit(o, filteredRefChain); if (!subTreeComplete) { Map<String, Object> members = findMembers(o, fieldPredicate); for (Map.Entry<String, Object> entry : members.entrySet()) { deepVisitInternal(entry.getValue(), fieldPredicate, visited, refChain, visitor); } } } } finally { refChain.removeLast(); } }
public TreeNode sinkZerosInBT2(TreeNode root) { if (deque == null) deque = new LinkedList<TreeNode>(); if (root == null) return null; if (root.val == 0) deque.addLast(root); else { if (!deque.isEmpty()) { swap(root, deque.pollFirst()); deque.addLast(root); // need to push this new zero-node to end of deque } } sinkZerosInBT2(root.left); sinkZerosInBT2(root.right); if (deque.peekLast() == root) // there's no non-zero node for us to swap, poll the zero node deque.pollLast(); return root; }
/** Undo the last entry that was added to this history. */ public void undo() { if (canUndo()) { final HistoryAction entry = undoList.removeLast(); entry.undo(); redoList.addLast(entry); } }
/** Do the last entry that was undone again. */ public void redo() { if (canRedo()) { final HistoryAction entry = redoList.removeLast(); entry.redo(); undoList.addLast(entry); } }
private void buildDoWhileStatement(DoWhileStatementTree tree) { DoWhileStatementTree s = tree; Block falseBranch = currentBlock; Block loopback = createBlock(); // process condition currentBlock = createBranch(s, loopback, falseBranch); buildCondition(s.condition(), loopback, falseBranch); // process body currentBlock = createBlock(currentBlock); continueTargets.addLast(loopback); breakTargets.addLast(falseBranch); build(s.statement()); breakTargets.removeLast(); continueTargets.removeLast(); loopback.successors.add(currentBlock); currentBlock = createBlock(currentBlock); }
@Override public void exitDoubleOperand(@NotNull DoubleOperandContext ctx) { double value = Double.parseDouble(ctx.FLOAT().getText()); if (ctx.DASH() != null) { value = -1 * value; } operandQueue.addLast(new DoubleOperand(value)); }
@Override public void exitLongOperand(@NotNull LongOperandContext ctx) { long value = Long.parseLong(ctx.INT().getText()); if (ctx.DASH() != null) { value = -1 * value; } operandQueue.addLast(new LongOperand(value)); }
/** * Creates connection objects and pushes it into queue. * * @param factory Used to create JDBConnection implementations. * @param poolSize Number of JDBConnection implementations to create. * @param leaseTimeInMillis How long the client can use the connection before it expires. */ public ConnectionPool(JdbConnectionFactory factory, int poolSize, long leaseTimeInMillis) { for (int i = 0; i < poolSize; i++) { pooled.addLast(factory.create()); } this.factory = factory; this.leaseTimeInMillis = leaseTimeInMillis; }
/** * Add a entry to the history list. This causes that the redo list is cleared and in case the undo * list is getting too long the oldest entry is removed. * * @param entry the entry to add to this list */ @SuppressWarnings("nls") public void addEntry(final HistoryAction entry) { undoList.addLast(entry); redoList.clear(); while (undoList.size() > MAX_HISTORY_LENGHT) { undoList.removeFirst(); } }
/** * Return a JdbConnection object back to the pool. * * @param jdbConnection The object retrieved from the pool via borrow() * @throws ConnectionPoolException Throws if connection has already been returned or forced to * expire */ public synchronized void forfeit(JdbConnection jdbConnection) throws ConnectionPoolException { if (borrowed.containsKey(jdbConnection)) { borrowed.remove(jdbConnection); pooled.addLast(jdbConnection); } else { throw new ConnectionPoolException("Connection already returned or forced to expire"); } }
private void buildForEachStatement(ForEachStatement tree) { // TODO(npe) One solution is to create a forstatement node depending on type of expression // (iterable or array) and build CFG from it. Block afterLoop = currentBlock; currentBlock = createBlock(); Block loopback = currentBlock; continueTargets.addLast(loopback); breakTargets.addLast(afterLoop); build(tree.statement()); breakTargets.removeLast(); continueTargets.removeLast(); currentBlock = createBranch(tree, currentBlock, afterLoop); loopback.successors.add(currentBlock); build(tree.variable()); build(tree.expression()); currentBlock = createBlock(currentBlock); }