public static List<List<Integer>> levelOrderBottom(TreeNode root) { if (root == null) { return new ArrayList<>(); } List<List<Integer>> res = new ArrayList<>(); List<Integer> level = new ArrayList<>(); Queue<TreeNode> queue = new LinkedList<>(); // 新建一个queue,用来记录哪些nodes是目前的波前 queue.add(root); // 向root注水作为波前 queue.add(null); // 在波前队列queue加null作为Flag代表这层level已访问结束 while (queue.size() != 0) { TreeNode u = queue.poll(); if (u != null) { level.add(u.val); /* * 波前u向其所有有连同的node扩散 * u是v的predecessor前驱 or parent * v是u的 descendent后记 * */ if (u.left != null) { queue.add(u.left); } if (u.right != null) { queue.add(u.right); } } else { res.add(level); level = new ArrayList<Integer>(); if (!queue.isEmpty()) { queue.add(null); } } } Collections.reverse(res); return res; }
public List<List<Integer>> levelOrderBottom(TreeNode root) { List<List<Integer>> ret = new ArrayList<>(); if (root == null) { return ret; } Stack<List<Integer>> tmpStack = new Stack<>(); Queue<TreeNode> tmpQueue = new LinkedList<>(); tmpQueue.add(root); while (tmpQueue.size() != 0) { int length = tmpQueue.size(); List<Integer> tmp = new ArrayList<>(); while (length != 0) { TreeNode topNode = tmpQueue.poll(); if (topNode.right != null) { tmpQueue.add(topNode.right); } if (topNode.left != null) { tmpQueue.add(topNode.left); } tmp.add(topNode.val); length--; } tmpStack.push(tmp); } while (!tmpStack.empty()) { ret.add(tmpStack.pop()); } return ret; }
/** * Run Method which simulates the number of threads running on the bridge * * @param None * @return None */ public void run() { while (true) { Truck theTruck; // Stores the Truck Object // synchronized on truck queue before removing the truck objects synchronized (theTruckQueue) { // If there are no Trucks then wait for trucks to arrive while (theTruckQueue.isEmpty()) { try { theTruckQueue.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } theTruck = theTruckQueue.remove(); } // Check for the maximum trucks allowed on the bridge and max weight // allowed on the bridge // Do not allow any more trucks if we exceed any of the limit while (theBridgeQueue.size() == MAX_SIZE || (theTruck.getWeight() + getTotalWeight()) >= MAX_WEIGHT) { System.out.println("Total number of trucks on Bridge: " + theBridgeQueue.size()); System.out.println("Total Weight on Bridge is: " + getTotalWeight()); Truck truckOnBridge = theBridgeQueue.remove(); System.out.println("The truck Entered " + truckOnBridge.getSide() + " of the Bridge left"); } // Allow the trucks on the bridge on first come first serve basis System.out.println("Truck " + theTruck.getSide() + " is Entering the Bridge"); theBridgeQueue.add(theTruck); System.out.println("Truck " + theTruck.getSide() + " is running on the Bridge"); } }
protected static <T> void parseEDISegmentOrSegmentGroup( EDIMessage ediMessage, T object, Iterator<Field> fieldIterator, Queue<String> lookAhead, SegmentIterator segmentIterator) throws EDIMessageException, IllegalAccessException, InvocationTargetException, InstantiationException, ClassNotFoundException, ConversionException { if (!fieldIterator.hasNext()) { throw new EDIMessageException("No more fields to read."); } if (!segmentIterator.hasNext() && lookAhead.size() == 0) { return; } // get the queued object first... String line = lookAhead.size() > 0 ? lookAhead.remove() : segmentIterator.next(); // match up the field with the line... FieldMatch fm = advanceToMatch(ediMessage, fieldIterator, line); // if (fm != null) { Class<?> fieldType = getEDISegmentOrGroupType(fm.getField()); if (fieldType.isAnnotationPresent(EDISegment.class)) { processSegment(ediMessage, object, lookAhead, segmentIterator, fm); } else if (fieldType.isAnnotationPresent(EDISegmentGroup.class)) { processSegmentGroup(ediMessage, object, lookAhead, segmentIterator, fm); } } else { lookAhead.add(line); } }
/** * "Push" new content to consumers: publish to this input stream readers new content to be read * from <code>inputStream</code> parameter. This * * @param inputStream New content for producers * @throws IOException If this input stream was closed. * @throws IllegalArgumentException If <code>inputStream</code> is <code>null</code>. * @see #close() */ public void push(InputStream inputStream) throws IOException { if (inputStream == null) { throw new IllegalArgumentException("Input stream can not be null."); } if (isClosed) { throw new IOException("Stream is closed"); } while (!inputStreamBuffer.offer(inputStream)) { debug("[P] Waiting for a read to complete (" + inputStreamBuffer.size() + ")"); synchronized (consumerMonitor) { consumerMonitor.notifyAll(); } if (!inputStreamBuffer.offer(inputStream)) { synchronized (producerMonitor) { try { producerMonitor.wait(); } catch (InterruptedException e) { throw new RuntimeException(e); } } } debug("[P] End of wait"); } debug("[P] Added a new input stream (buffer now has " + inputStreamBuffer.size() + " streams)"); }
public void run() { while (isConnected()) { /*try { Thread.sleep(500); } catch (InterruptedException e1) { // TODO Auto-generated catch block e1.printStackTrace(); }*/ // take out a message from Queue and send it try { if (messageQueue.size() > 0) { Log.debug("Number of messages in Queue = " + messageQueue.size()); } OpenIGTMessage msg = messageQueue.poll(); if (msg != null) { sendMessage(msg); } else if (curPos != null) { sendMessage(curPos); curPos = null; } } catch (Exception e) { if (!messageQueue.isEmpty()) { messageQueue .clear(); // clear message queue if ws not able to send as that is a connection // problem Log.debug( "Clearing Message Sender Queue ; Number of messages in Queue = " + messageQueue.size()); } // TODO Auto-generated catch block e.printStackTrace(); } } Log.debug("Stopped IGTLink client Sender"); }
private void createTaxis(int starthr, int endhr) { System.out.println(this.taxisOverTime); vqueue = new LinkedList<VData>(); vdata = new ArrayList<VData>(); for (int i = starthr; i <= endhr; i++) { List<TaxiDemandPerLor> demandPerLor; DemandPerLorParser dpl = new DemandPerLorParser(); Integer day = (i / 24) + 15; Integer hr = i % 24; String hrstring = String.format("%02d", hr); String filename = DATADIR + "OD/demandperLorHr/OD_201304" + day.toString() + hrstring + "_OD.csv"; BerlinVehicleGenerator.read(filename, dpl); demandPerLor = dpl.getDemand(); int currentVeh = this.taxisOverTime.get(i); if (i == starthr) addStartVehicles(currentVeh, demandPerLor, hr); else { int lastVeh = this.taxisOverTime.get(i - 1); if (currentVeh > lastVeh) { addTaxis(currentVeh - lastVeh, demandPerLor, hr); System.out.println(currentVeh + ":" + lastVeh + " a: " + vqueue.size()); } else if (currentVeh < lastVeh) { if (!(hr > 24)) removeTaxis(lastVeh - currentVeh, hr); System.out.println(currentVeh + ":" + lastVeh + " r: " + vqueue.size()); } } } removeTaxis(vqueue.size(), endhr % 24 + 1); }
public int compute(int cycles) throws HandlerException { System.out.println( "dbpedia spreader: " + cycles + " cycles over " + seeds.length + " seeds: " + seeds[0] + "..."); for (int i = 0; i < cycles; i++) { if (0 == curGen.size()) { if (0 == nextGen.size()) { return 0; } else { System.out.println("weight " + weight + " --> " + weight * DECAY); weight *= DECAY; Queue<Resource> tmp = curGen; curGen = nextGen; nextGen = tmp; } } else { Resource r = curGen.remove(); stepRelated(sailConnection, r, weight, vector, nextGen); } } return cycles; }
@Override public synchronized int read(byte[] b, int off, int len) throws IOException { if (len == 0) { return 0; } try { while (state_ == State.OPEN && queue_.isEmpty()) { wait(); } if (state_ == State.KILLED) { throw new IOException("Stream has been closed"); } if (state_ == State.CLOSED && queue_.isEmpty()) { return -1; } if (len > queue_.size()) { len = queue_.size(); } for (int i = 0; i < len; ++i) { b[off++] = queue_.remove(); } return len; } catch (InterruptedException e) { throw new IOException("Interrupted"); } }
// Returns a code tree that is optimal for these frequencies. Always contains at least 2 symbols, // to avoid degenerate trees. public CodeTree buildCodeTree() { // Note that if two nodes have the same frequency, then the tie is broken by which tree contains // the lowest symbol. Thus the algorithm is not dependent on how the queue breaks ties. Queue<NodeWithFrequency> pqueue = new PriorityQueue<NodeWithFrequency>(); // Add leaves for symbols with non-zero frequency for (int i = 0; i < frequencies.length; i++) { if (frequencies[i] > 0) pqueue.add(new NodeWithFrequency(new Leaf(i), i, frequencies[i])); } // Pad with zero-frequency symbols until queue has at least 2 items for (int i = 0; i < frequencies.length && pqueue.size() < 2; i++) { if (i >= frequencies.length || frequencies[i] == 0) pqueue.add(new NodeWithFrequency(new Leaf(i), i, 0)); } if (pqueue.size() < 2) throw new AssertionError(); // Repeatedly tie together two nodes with the lowest frequency while (pqueue.size() > 1) { NodeWithFrequency nf1 = pqueue.remove(); NodeWithFrequency nf2 = pqueue.remove(); pqueue.add( new NodeWithFrequency( new InternalNode(nf1.node, nf2.node), Math.min(nf1.lowestSymbol, nf2.lowestSymbol), nf1.frequency + nf2.frequency)); } // Return the remaining node return new CodeTree((InternalNode) pqueue.remove().node, frequencies.length); }
private void adjustClientCount() { if (m_syncRequestClientCount < m_syncRequestClients.size()) { reduceClients(m_syncRequestClientCount); } else if (m_syncRequestClientCount > m_syncRequestClients.size()) { increaseClients(m_syncRequestClientCount); } }
private void rightSideViewHelper(List<Integer> result, Queue<TreeNode> currLevel) { if (null == currLevel || currLevel.size() == 0) { return; } Queue<TreeNode> nextLevel = new LinkedList<>(); while (currLevel.size() != 1) { TreeNode node = currLevel.poll(); if (node.left != null) { nextLevel.add(node.left); } if (node.right != null) { nextLevel.add(node.right); } } TreeNode last = currLevel.poll(); result.add(last.val); if (last.left != null) { nextLevel.add(last.left); } if (last.right != null) { nextLevel.add(last.right); } rightSideViewHelper(result, nextLevel); }
protected void sendStreamOfCommands(int[] sequenceNumbers, boolean expected, int expectedCount) { for (int i = 0; i < sequenceNumbers.length; i++) { int commandId = sequenceNumbers[i]; ConsumerInfo info = new ConsumerInfo(); info.setSelector("Cheese: " + commandId); info.setCommandId(commandId); transport.onCommand(info); } Queue<Object> exceptions = listener.getExceptions(); Queue<Object> commands = listener.getCommands(); if (expected) { if (!exceptions.isEmpty()) { Exception e = (Exception) exceptions.remove(); e.printStackTrace(); fail("Caught exception: " + e); } assertEquals("number of messages received", expectedCount, commands.size()); assertEquals("Should have no buffered commands", 0, transport.getBufferedCommandCount()); } else { assertTrue("Should have received an exception!", exceptions.size() > 0); Exception e = (Exception) exceptions.remove(); LOG.info("Caught expected response: " + e); } }
/** * Close this stream and perform some checks: * * <ul> * <li>Mark this stream as closed (no more calls to {@link #push(java.io.InputStream)} are * allowed) * <li>Closes any remaining stream pushed to this stream * </ul> * * <p>Calling this method wakes up any thread blocked on {@link #read()} * * <p>Wait till all streams pushed to this stream (and stored in <code>inputStreamBuffer</code>) * are processed by a reader. * * <p>When this method exits, the buffer is empty and the last stream in buffer is fully read * (i.e. until read() returns -1). * * <p><b>Note:</b> if {@link #setConsumerThread(Thread)} was previously called, this method will * wait for the death of consumer before returning. * * @throws IOException In case at least one stream in buffer hasn't been read. * @see java.io.InputStream#close() */ @Override public void close() throws IOException { super.close(); isClosed = true; warmUpStrategy = NoWarmUpStrategy.INSTANCE; // In case close() is called before end of warm up. synchronized (consumerMonitor) { consumerMonitor.notifyAll(); } debug("[P] Input stream buffer size: " + inputStreamBuffer.size()); debug("[P] Has finished read: " + consumeStrategy.isConsumed()); while (!inputStreamBuffer.isEmpty() || !consumeStrategy.isConsumed()) { try { debug( "[P] Waiting for exhaust... (" + inputStreamBuffer.size() + " buffer(s) remaining / consumer finished: " + consumeStrategy.isConsumed() + ")"); synchronized (exhaustLock) { exhaustLock.wait(200); } // In case we got woken up due to a failure throwLastFailure(); debug("[P] Waiting for exhaust done."); } catch (InterruptedException e) { throw new RuntimeException(e); } } // In case failure happened on very last read. throwLastFailure(); debug("[P] Close completed."); }
/** * put the flip lake tile of the game * * @param players list of players */ private void setUpLakeTile(Queue<Player> players) { Random r = new Random(); int randomRedLantern = r.nextInt(players.size()); Queue<Color> color = startLakeTile.getColorOfFourSides(); // change the current player who get red lantern card color.add(color.remove()); for (int i = 0; i < randomRedLantern; i++) { players.add(players.remove()); } int current_number_player = 0; // add index to player for (int i = 0; i < players.size(); i++) { Player p = players.remove(); p.setIndex(i); players.add(p); } for (Color lantern_color : color) { if (current_number_player == players.size()) { break; } else { current_number_player++; } Player p = players.remove(); p.getLanternCards().add(supply.get(lantern_color).pop()); players.add(p); } }
public void addPlaneFromBoard(AirplaneSprite plane) { if (hangerPlanes.size() == 4) { throw new IllegalStateException("Hanger Render Manager to full to add a plane to the runway"); } plane.moveToPoint(spawnPoints.get(hangerPlanes.size())); hangerPlanes.add(plane); }
public void addPlane(AirplaneSprite plane) { if (hangerPlanes.size() == 4) { throw new IllegalStateException("Hanger Render Manager to full to add a plane to the runway"); } ImmutablePoint2 position = spawnPoints.get(hangerPlanes.size()); plane.moveToPoint(position); hangerPlanes.add(plane); }
/** * Constructor of play area get all stuff of starting play area depend on number of players * * @param players list of players */ public PlayArea(Queue<Player> players) { numberOfFavorTokens = 20; supply = new Supply(players.size()); lakeTilesOnBoard = new LakeTile[65][65]; initializeLakeTiles(players.size()); lakeTilesOnBoard[32][32] = startLakeTile; initializeDedicationTokens(players.size()); setUpLakeTile(players); }
public void expectNoMoreEvents() { int before = events.size(); try { Thread.sleep(1); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } int after = events.size(); assertThat("expected no more events, but still got some more: " + events, after, is(before)); }
public double next(int val) { if (q.size() == this.max) { total -= q.poll(); } q.offer(val); total += val; return (double) total / q.size(); }
public boolean hasNext() throws NoRecordsMatchException, BadResumptionTokenException, CannotDisseminateFormatException, NoSetHierarchyException, InternalHarvestException { if (_queue == null || (_queue.size() == 0 && resumption != null && !resumption.trim().equals(""))) { if (_queue == null) _queue = new LinkedList<Identifier>(); this.harvest(); } return (_queue.size() > 0); }
@Override public void sample() throws RDFHandlerException { getStartNodes(); Utility.logInfo(queue.size()); int u, v, pick, index; int individualLimit = statementLimit / queue.size(), currentLimit = 0; RDFEdge edge; List<RDFEdge> edges; Stack<Integer> stack = new Stack<Integer>(); while (true) { if (noOfStatements >= statementLimit) { System.out.println("The number of statements in the sampling: " + noOfStatements); return; } if (noOfStatements >= currentLimit) { stack.clear(); } if (stack.isEmpty()) { if (queue.isEmpty()) v = rand.nextInt(m_graph.numberOfIndividuals); else { v = queue.poll(); currentLimit += individualLimit; } stack.add(v); // Utility.logInfo(noOfStart + " new start: " + m_graph.getRawString(v)); visit(v); } u = stack.peek(); if (rand.nextInt(100) < 15) { stack.pop(); continue; } if ((edges = m_graph.edges.get(u)) == null || edges.size() == 0) { stack.clear(); continue; } index = 0; pick = rand.nextInt(edges.size()); for (Iterator<RDFEdge> iter = edges.iterator(); iter.hasNext(); ++index) { edge = iter.next(); if (index == pick) { stack.add(v = edge.m_dst); visit(v); m_writer.handleStatement(m_graph.getStatement(u, edge.m_label, edge.m_dst)); ++noOfStatements; iter.remove(); } } } }
public static void assertEqual(Queue<NdPoint> expected, Queue<NdPoint> actual) { String error = String.format("expected: %s but was: %s", expected, actual); assertEquals(error, expected.size(), actual.size()); Iterator<NdPoint> iexpect = expected.iterator(); Iterator<NdPoint> iactual = actual.iterator(); while (iexpect.hasNext()) { NdPoint e = iexpect.next(); NdPoint a = iactual.next(); assertTrue(error, e.equals(a)); } }
public String toString() { return String.format( "%s [%d/%d@%d,%d/%d@%d,%d/%d@-]", getClass().getSimpleName(), _headers.size(), _maxSize, _headerSize, _buffers.size(), _maxSize, _bufferSize, _others.size(), _maxSize); }
public void runEnqueuedTasks() { // run reasoner if it is not yet running if (isReasoningEnabled() && !running) { // ensure that only one reasoner is started at the same time reasonerLock.lock(); try { running = true; // run reasoner as long as there are tasks in the queue; if new tasks are added // while the reasoner is still running, they are executed in subsequent iterations // of the loop while (!taskQueue.isEmpty() && isReasoningEnabled()) { SystemStatus status = new SystemStatus( "Reasoner (" + taskQueue.size() + (taskQueue.size() > 1 ? " tasks remaining)" : " task remaining)")); status.setId("reasonerStatus"); statusService.addSystemStatus(status); currentTask = taskQueue.poll(); if (currentTask == null) { log.error("task is null!"); } try { processTask(currentTask); } catch (SecurityException e) { log.error("error while committing transaction (security exception)", e); } catch (IllegalStateException e) { log.error("error while committing transaction (illegal state)", e); } finally { statusService.removeSystemStatus(status); } } } finally { // release lock running = false; reasonerLock.unlock(); } } else if (!isReasoningEnabled()) { log.info( "online reasoning disabled; just enqueuing reasoning task without starting reasoner"); } else if (running) { log.info("reasoner already running; just enqueuing reasoning task"); } }
public void fillQueue() { while (images.size() < this.minSize && paths.size() > 0) { String path = paths.poll(); if (path != null) { try { Image img = ImageIO.read(new File(path)); images.add(img); System.out.println("Caching " + path); } catch (IOException ioe) { // TODO: handle exception } } } }
// Removes the element on top of the stack. public void pop() { if (q1.isEmpty()) { while (q2.size() > 1) { q1.offer(q2.poll()); } q2.poll(); return; } if (q2.isEmpty()) { while (q1.size() > 1) { q2.offer(q1.poll()); } q1.poll(); } }
public void restore_from_save(Queue<cell_w_coor> Q_for_pack, Vector<Coor> Q_of_cell) { this.Q_of_cell = Q_of_cell; System.out.println(Q_for_pack.size()); // Resotre all live cell into grid while (Q_for_pack.size() != 0) { cell_w_coor temp = Q_for_pack.poll(); cells[temp.z][temp.x][temp.y] = temp.cell; // System.out.println(temp.z + " " + temp.x + " " + temp.y); } // Refresh screen this.repaint(); }
public Object evaluate(EditorAdaptor vim, Queue<String> command) { String next = command.poll(); int index = next.indexOf('='); if (index < 0) { noSuchOptionMessage(vim, next); return null; } String optName = next.substring(0, index).trim(); String value = next.substring(index + 1); if (command.size() > 0) { // restore preceding space and spaces between tokens value += " " + StringUtils.join(" ", command); } Option<String> strOpt; Option<Integer> intOpt; try { if ((strOpt = find(Options.STRING_OPTIONS, optName)) != null) set(vim, strOpt, value); else if ((intOpt = find(Options.INT_OPTIONS, optName)) != null) set(vim, intOpt, Integer.valueOf(value)); else noSuchOptionMessage(vim, optName); } catch (ValueException e) { invalidValueMessage(vim, value); } catch (NumberFormatException e) { invalidValueMessage(vim, value); } return null; }
/** * Adds a ServiceRequest to the collection, and calls notifies a single waiting thread. * * @param item * @return */ public boolean enqueue(ServiceRequest item) { synchronized (this) { System.out.println(Thread.currentThread().getName() + " adding: " + item); while (queue.size() == upperBound) { try { System.out.println( Thread.currentThread().getName() + " found queue size: " + queue.size()); wait(); } catch (InterruptedException e) { } } queue.add(item); notifyAll(); return true; } }