@Test public void testIsEmpty() { assertTrue(deque.isEmpty()); deque.addFront(3); assertFalse(deque.isEmpty()); deque.removeFront(); assertTrue(deque.isEmpty()); }
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; }
// unit testing public static void main(String[] args) { Deque<Integer> deq = new Deque<Integer>(); boolean res; res = deq.isEmpty(); res = deq.isEmpty(); res = deq.isEmpty(); deq.addFirst(3); // deq.addFirst(5); int a = deq.removeFirst(); for (int i : deq) { StdOut.println(i); } }
@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); }
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; }
// 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; }
/** * @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; }
@Override public void visitAssignmentStatement(AssignmentStatement assignmentStatement) { LocalReference localReference = assignmentStatement.getLocalReference(); String referenceName = localReference.getName(); if (!localReference.isModuleState()) { if (!stack.isEmpty()) { assignmentStatement.setLocalReference( context().referenceTableStack.peek().get(referenceName)); } if (assignmentStatement.isDeclaring()) { locallyDeclared(referenceName); } } else { locallyDeclared(referenceName); } locallyAssigned(referenceName); assignmentStatement.getExpressionStatement().accept(this); if (assignmentStatement.getExpressionStatement() instanceof ClosureReference) { ClosureReference closure = (ClosureReference) assignmentStatement.getExpressionStatement(); GoloFunction target = closure.getTarget(); if (target.getSyntheticParameterNames().contains(referenceName)) { target.removeSyntheticParameter(referenceName); target.setSyntheticSelfName(referenceName); } } }
@Test public void Deque_addLast_AddsTwo() { deque.addLast("firstString"); deque.addLast("secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 2); }
public void performIncludes(ModuleChain inclusionPoint, Deque<DynamicObject> moduleAncestors) { while (!moduleAncestors.isEmpty()) { DynamicObject mod = moduleAncestors.pop(); assert RubyGuards.isRubyModule(mod); inclusionPoint.insertAfter(mod); Layouts.MODULE.getFields(mod).addDependent(rubyModuleObject); } }
/* * stack contains all ancestors of the node, stack.peek() is its parent. */ private void mutateUp(@NotNull final Deque<ChildReferenceTransient> stack, MutableNode node) { while (!stack.isEmpty()) { final ChildReferenceTransient parent = stack.pop(); final MutableNode mutableParent = parent.mutate(this); mutableParent.setChild(parent.firstByte, node); node = mutableParent; } }
@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()); }
/** * Returns all values since last check and removes values from the queue. * * @return a new array with the value; never null */ @Override public List<T> getValue() { synchronized (buffer) { if (buffer.isEmpty()) return Collections.emptyList(); return new ArrayList<T>(buffer); } }
private void prune() { // Remove all values that are too old TimeInterval periodAllowed = cachedPeriod.before(buffer.getLast().getTimestamp()); while (!buffer.isEmpty() && !periodAllowed.contains(buffer.getFirst().getTimestamp())) { // Discard value buffer.removeFirst(); } }
private void definedInBlock(Set<String> references, Block block) { if (!stack.isEmpty()) { for (String ref : references) { context().definingBlock.put(ref, block); } context().allReferences.addAll(references); } }
@Test public void testAddThenRemove() { deque.addBack(3); assertEquals(new Integer(3), deque.removeBack()); deque.addFront(7); assertEquals(new Integer(7), deque.removeBack()); assertTrue(deque.isEmpty()); }
private void pushBlockTable(Block block) { if (!stack.isEmpty()) { if (!context().referenceTableStack.isEmpty()) { block.getReferenceTable().relink(context().referenceTableStack.peek()); } context().referenceTableStack.push(block.getReferenceTable()); } }
@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); }
private int findMaxArea(int[] height) { if (height == null || height.length == 0) return 0; int[] h = Arrays.copyOf(height, height.length + 1); int maxArea = 0; Deque<Integer> stack = new LinkedList(); int k = 0; while (k < h.length) { if (stack.isEmpty() || h[stack.peek()] <= h[k]) { stack.push(k++); } else { int t = stack.pop(); int leftIndex = (stack.isEmpty()) ? -1 : stack.peek(); int rightIndex = k; int tmpArea = h[t] * (rightIndex - leftIndex - 1); maxArea = Math.max(maxArea, tmpArea); } } return maxArea; }
@Override public void run() { while (!myDisposed) { boolean isEmpty; synchronized (filesToResolve) { isEmpty = filesToResolve.isEmpty(); } if (enableVetoes.get() > 0 || isEmpty || !resolveProcess.isDone() || HeavyProcessLatch.INSTANCE.isRunning() || PsiDocumentManager.getInstance(myProject).hasUncommitedDocuments()) { try { waitForQueue(); } catch (InterruptedException e) { break; } continue; } final Set<VirtualFile> files = pollFilesToResolve(); if (files.isEmpty()) continue; upToDate = false; myApplication.invokeLater( () -> { if (!resolveProcess.isDone()) return; log("Started to resolve " + files.size() + " files"); Task.Backgroundable backgroundable = new Task.Backgroundable(myProject, "Resolving files...", false) { @Override public void run(@NotNull final ProgressIndicator indicator) { if (!myApplication.isDisposed()) { processBatch(indicator, files); } } }; ProgressIndicator indicator; if (files.size() > 1) { // show progress indicator = new BackgroundableProcessIndicator(backgroundable); } else { indicator = new MyProgress(); } resolveProcess = ((ProgressManagerImpl) ProgressManager.getInstance()) .runProcessWithProgressAsynchronously(backgroundable, indicator, null); }, myProject.getDisposed()); flushLog(); } }
@Override public boolean add(@NotNull final ByteIterable key, @NotNull final ByteIterable value) { final ByteIterator it = key.iterator(); NodeBase node = root; MutableNode mutableNode = null; final Deque<ChildReferenceTransient> stack = new ArrayDeque<>(); while (true) { final NodeBase.MatchResult matchResult = node.matchesKeySequence(it); final int matchingLength = matchResult.matchingLength; if (matchingLength < 0) { final MutableNode prefix = node.getMutableCopy(this).splitKey(-matchingLength - 1, matchResult.keyByte); if (matchResult.hasNext) { prefix.hang(matchResult.nextByte, it).setValue(value); } else { prefix.setValue(value); } if (stack.isEmpty()) { root = new MutableRoot(prefix, root.sourceAddress); } else { final ChildReferenceTransient parent = stack.pop(); mutableNode = parent.mutate(this); mutableNode.setChild(parent.firstByte, prefix); } break; } if (!it.hasNext()) { if (node.hasValue()) { return false; } mutableNode = node.getMutableCopy(this); mutableNode.setValue(value); break; } final byte nextByte = it.next(); final NodeBase child = node.getChild(this, nextByte); if (child == null) { mutableNode = node.getMutableCopy(this); if (mutableNode.hasChildren() || mutableNode.hasKey() || mutableNode.hasValue()) { mutableNode.hang(nextByte, it).setValue(value); } else { mutableNode.setKeySequence(new ArrayByteIterable(nextByte, it)); mutableNode.setValue(value); } break; } stack.push(new ChildReferenceTransient(nextByte, node)); node = child; } ++size; mutateUp(stack, mutableNode); TreeCursorMutable.notifyCursors(this); return true; }
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; }
public int pop() { stack.pollLast(); size--; if (stack.isEmpty()) { // System.out.println("EMPTY"); return 0; } int result = stack.peekLast(); return result; }
private void reverseChangeLog() throws InvalidOperationException { Deque<Operation> operations = new LinkedList<>(this.changeLog); while (!operations.isEmpty()) { Operation operation = operations.pop(); if (!TokenHook.TokenType.Word.equals(operation.tokenType)) { Operation inverse = operation.getInverse(); Collection<Operation> c = new LinkedList<>(); c.add(inverse); this.applyOperations(c, false); } } }
// 检测是否合法:合法 0,不合法 -1 public int checkValid(String s) { Deque<Integer> q = new ArrayDeque<>(); for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); switch (c) { case '(': q.push(i); break; case ')': if (q.isEmpty()) { return -1; } else { q.pop(); } break; default: break; } } return q.isEmpty() ? 0 : -1; }
public int[] maxSlidingWindow(int[] nums, int k) { if (nums == null || k <= 0) return new int[0]; Deque<Integer> deque = new ArrayDeque<Integer>(); int n = nums.length; int[] r = new int[n - k + 1]; int ri = 0; for (int i = 0; i < n; i++) { while (!deque.isEmpty() && deque.peek() < i - k + 1) { deque.poll(); } while (!deque.isEmpty() && nums[i] > nums[deque.peekLast()]) { deque.pollLast(); } deque.offer(i); if (i >= k - 1) r[ri++] = nums[deque.peek()]; } return r; }
public String removeDuplicateLetters(String s) { Deque<Character> stack = new LinkedList<>(); Map<Character, Integer> count = new HashMap<>(); for (int i = 0; i < s.length(); i++) { count.compute( s.charAt(i), (key, val) -> { if (val == null) { return 1; } else { return val + 1; } }); } Set<Character> visited = new HashSet<>(); for (int i = 0; i < s.length(); i++) { char ch = s.charAt(i); count.put(ch, count.get(ch) - 1); if (visited.contains(ch)) { continue; } while (!stack.isEmpty() && stack.peekFirst() > ch && count.get(stack.peekFirst()) > 0) { visited.remove(stack.peekFirst()); stack.pollFirst(); } stack.offerFirst(ch); visited.add(ch); } StringBuffer buff = new StringBuffer(); while (!stack.isEmpty()) { buff.append(stack.pollLast()); } return buff.toString(); }
/** * Runs the server. The server will wait for some match info (which specifies the teams and set of * maps to run) and then begin running matches. */ public void run() { int aWins = 0, bWins = 0; while (!matches.isEmpty()) { Match match = matches.peek(); if (!finished.isEmpty()) match.setInitialTeamMemory(finished.getLast().getComputedTeamMemory()); try { debug("running match " + match); match.initialize(); runMatch(match, proxyWriter); finished.add(match); matches.remove(match); if (match.getWinner() == Team.A) aWins++; else if (match.getWinner() == Team.B) bWins++; match.finish(); // Allow best of three scrimmages -- single game scrims should still work fine // TODO:This "win mode" should probably be something from the database if (mode == Mode.TOURNAMENT || mode == Mode.SCRIMMAGE) { if (aWins == 2 || bWins == 2) break; } } catch (Exception e) { ErrorReporter.report(e); error("couldn't run match: "); this.state = State.ERROR; } } proxyWriter.terminate(); }
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; }
@Override protected AFCalculationResult computeLog10PNonRef( final VariantContext vc, final int defaultPloidy, final double[] log10AlleleFrequencyPriors, final StateTracker stateTracker) { Utils.nonNull(vc, "vc is null"); Utils.nonNull(log10AlleleFrequencyPriors, "log10AlleleFrequencyPriors is null"); Utils.nonNull(stateTracker, "stateTracker is null"); final int numAlternateAlleles = vc.getNAlleles() - 1; final List<double[]> genotypeLikelihoods = getGLs(vc.getGenotypes(), true); final int numSamples = genotypeLikelihoods.size() - 1; final int numChr = 2 * numSamples; // queue of AC conformations to process final Deque<ExactACset> ACqueue = new LinkedList<>(); // mapping of ExactACset indexes to the objects final Map<ExactACcounts, ExactACset> indexesToACset = new HashMap<>(numChr + 1); // add AC=0 to the queue final int[] zeroCounts = new int[numAlternateAlleles]; final ExactACset zeroSet = new ExactACset(numSamples + 1, new ExactACcounts(zeroCounts)); ACqueue.add(zeroSet); indexesToACset.put(zeroSet.getACcounts(), zeroSet); while (!ACqueue.isEmpty()) { // compute log10Likelihoods final ExactACset set = ACqueue.remove(); calculateAlleleCountConformation( set, genotypeLikelihoods, numChr, ACqueue, indexesToACset, log10AlleleFrequencyPriors, stateTracker); // clean up memory indexesToACset.remove(set.getACcounts()); } return getResultFromFinalState(vc, log10AlleleFrequencyPriors, stateTracker); }