public static void main(String[] args) {
int n = 10000;
if (args.length > 0) n = Integer.parseInt(args[0]);
List<Integer> sorted = new ArrayList<Integer>(n);
for (int i = 0; i < n; i++) sorted.add(new Integer(i));
List<Integer> shuffled = new ArrayList<Integer>(sorted);
Collections.shuffle(shuffled);
Queue<Integer> pq = new PriorityQueue<Integer>(n, new MyComparator());
for (Iterator<Integer> i = shuffled.iterator(); i.hasNext(); ) pq.add(i.next());
List<Integer> recons = new ArrayList<Integer>();
while (!pq.isEmpty()) recons.add(pq.remove());
if (!recons.equals(sorted)) throw new RuntimeException("Sort test failed");
recons.clear();
pq = new PriorityQueue<Integer>(shuffled);
while (!pq.isEmpty()) recons.add(pq.remove());
if (!recons.equals(sorted)) throw new RuntimeException("Sort test failed");
// Remove all odd elements from queue
pq = new PriorityQueue<Integer>(shuffled);
for (Iterator<Integer> i = pq.iterator(); i.hasNext(); )
if ((i.next().intValue() & 1) == 1) i.remove();
recons.clear();
while (!pq.isEmpty()) recons.add(pq.remove());
for (Iterator<Integer> i = sorted.iterator(); i.hasNext(); )
if ((i.next().intValue() & 1) == 1) i.remove();
if (!recons.equals(sorted)) throw new RuntimeException("Iterator remove test failed.");
}
/**
* Returns date in the format: neededDatePattern, in case if year or month isn't entered, current
* year/month is put.
*
* @return correct date.
*/
private Date getCorrectedDate(String enteredDate) {
Queue<String> dateParts = new ArrayDeque<>(3);
StringBuilder number = new StringBuilder();
for (char symbol : enteredDate.toCharArray()) {
if (Character.isDigit(symbol)) {
number.append(symbol);
} else if (number.length() > 0) {
dateParts.add(number.toString());
number = new StringBuilder();
}
}
if (number.length() > 0) {
dateParts.add(number.toString());
}
Calendar currentDate = Calendar.getInstance();
switch (dateParts.size()) {
case 1:
dateParts.add(Integer.toString(currentDate.get(Calendar.MONTH) + 1));
case 2:
dateParts.add(Integer.toString(currentDate.get(Calendar.YEAR)));
}
try {
return new SimpleDateFormat("dd.MM.yyyy")
.parse(dateParts.remove() + '.' + dateParts.remove() + '.' + dateParts.remove());
} catch (ParseException e) {
throw new RuntimeException(e); // todo change exception
}
}
public void addItems(List<String> names, List<T> items) {
if (!locationMap.isEmpty()) {
throw new IllegalStateException("addItems can only be called once for any given Lattice");
}
Queue<String> nameQueue = new LinkedList<String>(names);
Queue<T> itemQueue = new LinkedList<T>(items);
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
for (int k = 0; k < size; k++) {
if (nameQueue.isEmpty() || itemQueue.isEmpty()) return;
String name = nameQueue.remove();
T item = itemQueue.remove();
locationMap.put(name, new PVector(i, j, k));
contentsMap.put(name, item);
}
}
}
if (!nameQueue.isEmpty()) {
log.warn(
"Could not add all items to lattice of size "
+ size
+ ". Items remaining: "
+ nameQueue.size());
}
}
/**
* It is synchronized as it does merging of adjacent blocks. An easiest way to somewhat address
* fragmentation problem.
*
* @param pointer2free
*/
private void freeAndMerge(Pointer pointer2free) {
synchronized (pointers) {
pointers.remove(pointer2free);
// merge adjacent blocks
if (null != pointer2free.getPrev() && pointer2free.getPrev().isFree()) {
// Merge previous
pointers.remove(pointer2free.getPrev());
pointer2free.setStart(pointer2free.getPrev().getStart());
pointer2free.setPrev(pointer2free.getPrev().getPrev());
// Recursive call
freeAndMerge(pointer2free);
}
if (null != pointer2free.getNext() && pointer2free.getNext().isFree()) {
// Merge Next
pointers.remove(pointer2free.getNext());
pointer2free.setEnd(pointer2free.getNext().getEnd());
pointer2free.setNext(pointer2free.getNext().getNext());
// Recursive call
freeAndMerge(pointer2free);
}
if (!pointer2free.isFree()) {
pointer2free.setFree(true);
pointer2free.setClazz(null);
pointers.add(pointer2free);
}
}
}
public static void lightChange(Queue<Car> q) {
// if light is true, that means the green light is for N and S
// This means we must change the cars wait times in E and W
Queue<Car> temp = new LinkedList<Car>();
Car tc;
while (!q.isEmpty()) {
tc = q.remove();
temp.add(tc);
}
int tnum = 1;
q.clear();
// System.out.println("In the light change");
while (!temp.isEmpty()) {
Car tcar = temp.remove();
// System.out.println("Light Change: " + tcar.display());
if (tnum == 1) {
tcar.setTotalWait(3);
tcar.setWaitTime(3);
q.add(tcar);
} else if (tnum == 2) {
tcar.setTotalWait(2);
tcar.setWaitTime(2);
q.add(tcar);
} else {
tcar.setTotalWait(1);
tcar.setWaitTime(1);
q.add(tcar);
}
tnum++;
}
}
// Algorithm to randomly shuffle the elements of a message.
final Message shuffle(Message message) throws FormatException {
Message shuffled = messages.make();
// Read all elements of the packet and insert them in a Queue.
Queue<String> old = new LinkedList<>();
int N = 0;
while (!message.isEmpty()) {
old.add(message.readString());
message = message.rest();
N++;
}
// Then successively and randomly select which one will be inserted until none remain.
for (int i = N; i > 0; i--) {
// Get a random number between 0 and N - 1 inclusive.
int n = crypto.getRandom(i - 1);
for (int j = 0; j < n; j++) {
old.add(old.remove());
}
// add the randomly selected element to the queue.
shuffled = shuffled.attach(old.remove());
}
return shuffled;
}
/**
* 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);
}
}
int[] nextPillBFS(Node start) {
ArrayList<Node> alreadyVisited = new ArrayList<Node>();
Queue<Node> nextToVisit = new LinkedList<Node>();
Queue<Tuple> startDirection = new LinkedList<Tuple>();
ArrayList<Edge> firstDirections = start.getEdges();
for (int i = 0; i < firstDirections.size(); i++) {
Node nextFieldToVisit = firstDirections.get(i).end;
nextToVisit.add(nextFieldToVisit);
startDirection.add(new Tuple(nextFieldToVisit.x - start.x, nextFieldToVisit.y - start.y));
}
Node lastTouched;
Tuple beginningDirection;
while (true) {
if (nextToVisit.size() == 0) return new int[] {0, 0};
lastTouched = nextToVisit.remove();
beginningDirection = startDirection.remove();
if (alreadyVisited.contains(lastTouched)) continue;
if (lastTouched.hasPill()) {
break;
}
alreadyVisited.add(lastTouched);
ArrayList<Edge> neighbourEdges = lastTouched.getEdges();
for (int i = 0; i < neighbourEdges.size(); i++) {
nextToVisit.add(neighbourEdges.get(i).end);
startDirection.add(beginningDirection);
}
}
return new int[] {beginningDirection.x, beginningDirection.y};
}
/**
* 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 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);
}
}
private static int ladderLength(String start, String end, HashSet<String> dict) {
int len = 0;
Queue<String> wordQ = new LinkedList<String>();
Queue<Integer> distQ = new LinkedList<Integer>();
if (dict.size() == 0) return -1;
wordQ.add(start);
distQ.add(1);
while (!wordQ.isEmpty()) {
String currWord = wordQ.remove();
Integer currDist = distQ.remove();
if (currWord.equals(end)) return currDist;
for (int i = 0; i < currWord.length(); i++) {
char[] currArray = currWord.toCharArray();
for (char c = 'a'; c <= 'z'; c++) {
currArray[i] = c;
String newStr = new String(currArray);
if (dict.contains(newStr)) {
wordQ.add(newStr);
distQ.add(currDist + 1);
dict.remove(newStr);
}
}
}
}
return len;
}
private boolean setUpRemoteEngines(TestPlanEntity testPlan, Queue<Engine> engineQ) {
List<EngineRole> engineRoles = testPlan.getTestTenant().getEngineList();
Queue<EngineRole> engineRoleQ = new ArrayDeque<>();
engineRoleQ.addAll(engineRoles);
while (!engineRoleQ.isEmpty()) {
EngineRole role = engineRoleQ.remove();
if (engineQ.size() < engineRoles.size()) {
_logger.error(
String.format(
"Testplan: %d can't init. Not enough available engines", testPlan.getId()));
return true;
}
while (true) {
Engine e = engineQ.remove();
if (engineService.setRemoteEngineRole(e, role)) {
break;
}
if (engineQ.isEmpty()) {
_logger.error(
String.format(
"Testplan: %d can't init. Not enough available engines", testPlan.getId()));
return true;
}
}
}
return false;
}
// 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);
}
@SuppressWarnings("unchecked")
private final Command mergeGetCommands(
final Command currentCmd,
final Queue writeQueue,
final Queue<Command> executingCmds,
CommandType expectedCommandType) {
Map<Object, Command> mergeCommands = null;
int mergeCount = 1;
final CommandCollector commandCollector = creatCommandCollector();
currentCmd.setStatus(OperationStatus.WRITING);
commandCollector.visit(currentCmd);
while (mergeCount < mergeFactor) {
Command nextCmd = (Command) writeQueue.peek();
if (nextCmd == null) {
break;
}
if (nextCmd.isCancel()) {
writeQueue.remove();
continue;
}
if (nextCmd.getCommandType() == expectedCommandType) {
if (mergeCommands == null) { // lazy initialize
mergeCommands = new HashMap<Object, Command>(mergeFactor / 2);
mergeCommands.put(currentCmd.getKey(), currentCmd);
}
if (log.isDebugEnabled()) {
log.debug("Merge get command:" + nextCmd.toString());
}
nextCmd.setStatus(OperationStatus.WRITING);
Command removedCommand = (Command) writeQueue.remove();
// If the key is exists,add the command to associated list.
if (mergeCommands.containsKey(removedCommand.getKey())) {
final AssocCommandAware mergedGetCommand =
(AssocCommandAware) mergeCommands.get(removedCommand.getKey());
if (mergedGetCommand.getAssocCommands() == null) {
mergedGetCommand.setAssocCommands(new ArrayList<Command>(5));
}
mergedGetCommand.getAssocCommands().add(removedCommand);
} else {
commandCollector.visit(nextCmd);
mergeCommands.put(removedCommand.getKey(), removedCommand);
}
mergeCount++;
} else {
break;
}
}
commandCollector.finish();
if (mergeCount == 1) {
return currentCmd;
} else {
if (log.isDebugEnabled()) {
log.debug("Merge optimieze:merge " + mergeCount + " get commands");
}
return newMergedCommand(mergeCommands, mergeCount, commandCollector, expectedCommandType);
}
}
@SuppressWarnings("synthetic-access")
@Override
public CurrencyLabelledMatrix1D buildObject(
final FudgeDeserializer deserializer, final FudgeMsg message) {
final FudgeMsg msg = message.getMessage(MATRIX_FIELD_NAME);
final Queue<String> labelTypes = new LinkedList<String>();
final Queue<FudgeField> labelValues = new LinkedList<FudgeField>();
final List<Currency> keys = new LinkedList<Currency>();
final List<Object> labels = new LinkedList<Object>();
final List<Double> values = new LinkedList<Double>();
for (final FudgeField field : msg) {
switch (field.getOrdinal()) {
case LABEL_TYPE_ORDINAL:
labelTypes.add((String) field.getValue());
break;
case KEY_ORDINAL:
keys.add(Currency.of((String) field.getValue()));
break;
case LABEL_ORDINAL:
labelValues.add(field);
break;
case VALUE_ORDINAL:
values.add((Double) field.getValue());
break;
}
if (!labelTypes.isEmpty() && !labelValues.isEmpty()) {
// Have a type and a value, which can be consumed
final String labelType = labelTypes.remove();
Class<?> labelClass;
try {
labelClass = LabelledMatrix1DBuilder.getLabelClass(labelType, _loadedClasses);
} catch (final ClassNotFoundException ex) {
throw new OpenGammaRuntimeException(
"Could not deserialize label of type " + labelType, ex);
}
final FudgeField labelValue = labelValues.remove();
final Object label = deserializer.fieldValueToObject(labelClass, labelValue);
// labels.add(Currency.of((String) label));
labels.add(label);
}
}
final int matrixSize = keys.size();
final Currency[] keysArray = new Currency[matrixSize];
keys.toArray(keysArray);
final Object[] labelsArray = new Object[matrixSize];
labels.toArray(labelsArray);
final double[] valuesArray = Doubles.toArray(values);
return new CurrencyLabelledMatrix1D(keysArray, labelsArray, valuesArray);
}
public void queueLinkedList() {
Queue queue = new LinkedList();
queue.add("One");
queue.add("Two");
queue.add("Three");
System.out.println(queue.remove());
System.out.println(queue.remove());
System.out.println(queue.remove());
}
void solve(Scanner in, PrintWriter out) {
int n = in.nextInt();
int k = in.nextInt();
int m = in.nextInt();
islands = new Island[n];
for (int i = 0; i < n; i++) {
islands[i] = new Island();
}
readEdges(in, k, false);
readEdges(in, m, true);
int bridgesUsed = 0;
Queue<Island> bfs = new LinkedList<Island>();
Queue<Island> candidates = new LinkedList<Island>();
Island nextRoot = islands[0];
while (nextRoot != null) {
bfs.add(nextRoot);
nextRoot = null;
while (!bfs.isEmpty()) {
Island land = bfs.remove();
land.visited = true;
for (Island other : land.tunnels) {
if (!other.visited) {
bfs.add(other);
}
}
for (Island other : land.bridges) {
if (!other.visited) {
candidates.add(other);
}
}
}
while (!candidates.isEmpty()) {
Island land = candidates.remove();
if (!land.visited) {
nextRoot = land;
bridgesUsed++;
break;
}
}
}
out.println(bridgesUsed);
}
/** @param charFreq */
static void caculateHuffManEncoding(CharFreq[] charFreq) {
Queue<CharFreq> pQueue = new PriorityQueue<HuffmanCoding.CharFreq>();
List<CharFreq> chF = Arrays.asList(charFreq);
pQueue.addAll(chF);
// Create Huffman tree
while (pQueue.size() > 1) {
CharFreq left = pQueue.remove();
CharFreq right = pQueue.remove();
CharFreq internal = new CharFreq(left.freq + right.freq, left, right);
pQueue.add(internal);
}
// huffManEncoding(pQueue.remove(), new StringBuilder());
huffManEncoding(pQueue.remove(), 0);
}
@Override
public StreamObserver<StreamingRecognizeRequest> streamingRecognize(
final StreamObserver<StreamingRecognizeResponse> responseObserver) {
final Object response = responses.remove();
StreamObserver<StreamingRecognizeRequest> requestObserver =
new StreamObserver<StreamingRecognizeRequest>() {
@Override
public void onNext(StreamingRecognizeRequest value) {
if (response instanceof StreamingRecognizeResponse) {
responseObserver.onNext((StreamingRecognizeResponse) response);
} else if (response instanceof Exception) {
responseObserver.onError((Exception) response);
} else {
responseObserver.onError(new IllegalArgumentException("Unrecognized response type"));
}
}
@Override
public void onError(Throwable t) {
responseObserver.onError(t);
}
@Override
public void onCompleted() {
responseObserver.onCompleted();
}
};
return requestObserver;
}
@Override
public String[] findFiles(final String folderName) {
File folder = new File(folderName);
if (!folder.exists()) {
throw new IllegalArgumentException();
}
List<String> foundFiles = new ArrayList<String>();
Queue<File> folders = new LinkedList<File>();
folders.add(folder);
while (!folders.isEmpty()) {
File currentFolder = folders.remove();
File[] currentFiles = currentFolder.listFiles();
for (File f : currentFiles) {
if (f.isDirectory()) {
folders.add(f);
} else if (f.isFile()) {
foundFiles.add(f.getAbsolutePath());
} else {
throw new RuntimeException("It isn't file or folder");
}
}
}
return foundFiles.toArray(new String[foundFiles.size()]);
}
/**
* removes any tags from the validator's queue that match the given element
*
* @param element to remove from the queue
*/
public void removeAll(String element) {
for (HtmlTag h : tags) {
if (h.toString().equals(element)) {
tags.remove(h);
}
}
}
private boolean existsUnblockedSemiDirectedPath(Node from, Node to, List<Node> cond, Graph G) {
Queue<Node> Q = new LinkedList<Node>();
Set<Node> V = new HashSet<Node>();
Q.offer(from);
V.add(from);
while (!Q.isEmpty()) {
Node t = Q.remove();
if (t == to) return true;
for (Node u : G.getAdjacentNodes(t)) {
Edge edge = G.getEdge(t, u);
Node c = Edges.traverseSemiDirected(t, edge);
if (c == null) continue;
if (cond.contains(c)) continue;
if (c == to) return true;
if (!V.contains(c)) {
V.add(c);
Q.offer(c);
}
}
}
return false;
}
/* Fill the bipartite graph if possible. */
boolean[] solve() {
Map<Integer, List<Integer>> gr = makeGraph();
boolean[] truthTable = new boolean[count];
// keep track of which ones we've visited
boolean[] visited = new boolean[count];
Queue<Integer> queue = new LinkedList<Integer>();
truthTable[0] = true; // assume the first person tells the truth
queue.add(0);
// Breadth first search on graph
while (!queue.isEmpty()) {
int next = queue.remove();
boolean truth = truthTable[next];
List<Integer> list = gr.get(next);
// Go through list and toggle when needed
for (int i = 0; i < list.size(); i++) {
int node = list.get(i);
if (!visited[node]) {
visited[node] = true;
truthTable[node] = !truth;
queue.add(node);
}
}
}
return truthTable;
}
/**
* Locate each unexpanded Structure|Sequence and: 1. check that none of its fields is referenced
* => do not expand 2. add all of its fields as leaves Note that #2 may end up adding additional
* leaf structs &/or seqs
*/
public void expand() {
// Create a queue of unprocessed leaf compounds
Queue<DapVariable> queue = new ArrayDeque<DapVariable>();
for (int i = 0; i < variables.size(); i++) {
DapVariable var = variables.get(i);
if (!var.isTopLevel()) continue;
// prime the queue
if (var.getSort() == DapSort.STRUCTURE || var.getSort() == DapSort.SEQUENCE) {
DapStructure struct = (DapStructure) var; // remember Sequence subclass Structure
if (expansionCount(struct) == 0) queue.add(var);
}
}
// Process the queue in prefix order
while (queue.size() > 0) {
DapVariable vvstruct = queue.remove();
DapStructure dstruct = (DapStructure) vvstruct;
for (DapVariable field : dstruct.getFields()) {
if (findVariableIndex(field) < 0) {
// Add field as leaf
this.segments.add(new Segment(field));
this.variables.add(field);
}
if (field.getSort() == DapSort.STRUCTURE || field.getSort() == DapSort.SEQUENCE) {
if (expansionCount((DapStructure) field) == 0) queue.add(field);
}
}
}
this.expansion = Expand.EXPANDED;
}
/** Sorts the index in the order of the date of publication of the posts. */
protected void sortIndexes() {
for (SingleIndex s : indexList) {
for (int i = 0; i < postsPerIndex && !queue.isEmpty(); i++) {
s.getPosts().add(queue.remove());
}
}
}
/**
* Using a serialized list of tree nodes to generate a binary tree. There is detail information:
* https://leetcode.com/problems/binary-tree-inorder-traversal/
*
* @param serializedTreeNode a serialized list of tree nodes
* @return the node of tree root
*/
public static TreeNode generateTree(String serializedTreeNode) {
String[] tokens = serializedTreeNode.split(",");
if (tokens.length <= 0) return null;
TreeNode root = new TreeNode(Integer.parseInt(tokens[0]));
Queue<TreeNode> queue = new LinkedList<>();
queue.add(root);
int pos = 1;
while (pos < tokens.length) {
TreeNode temp = queue.remove();
if (!tokens[pos].equals("#")) {
TreeNode left = new TreeNode(Integer.parseInt(tokens[pos]));
temp.left = left;
queue.add(left);
}
pos++;
if (pos >= tokens.length) break;
if (!tokens[pos].equals("#")) {
TreeNode right = new TreeNode(Integer.parseInt(tokens[pos]));
temp.right = right;
queue.add(right);
}
pos++;
}
return root;
}
/* Creates tree by mapping the array left to right, top to bottom. */
public static TreeNode createTreeFromArray(int[] array) {
if (array.length > 0) {
TreeNode root = new TreeNode(array[0]);
java.util.Queue<TreeNode> queue = new java.util.LinkedList<TreeNode>();
queue.add(root);
boolean done = false;
int i = 1;
while (!done) {
TreeNode r = (TreeNode) queue.element();
if (r.left == null) {
r.left = new TreeNode(array[i]);
i++;
queue.add(r.left);
} else if (r.right == null) {
r.right = new TreeNode(array[i]);
i++;
queue.add(r.right);
} else {
queue.remove();
}
if (i == array.length) done = true;
}
return root;
} else {
return null;
}
}
// Reads: value | '[' value1, value2, valueN ']'
private Object readValue(Queue<String> tokens) {
String token = tokens.poll();
if (!"[".equals(token)) {
return token;
} else {
List<Object> values = new ArrayList<Object>();
while (true) {
if ("]".equals(tokens.peek())) {
tokens.remove();
break;
}
Object value = readValue(tokens);
values.add(value);
String delimiter = tokens.poll();
if ("]".equals(delimiter)) {
break;
} else if (!",".equals(delimiter)) {
throw new IllegalArgumentException(String.format("Expected a comma after [%s]!", value));
}
}
return values;
}
}
public void adjustTellerNumber() {
// This is actually a control system. By adjusting
// the numbers, you can reveal stability issues in
// the control mechanism.
// If line is too long, add another teller:
if (customers.size() / workingTellers.size() > 2) {
// If tellers are on break or doing
// another job, bring one back:
if (tellersDoingOtherThings.size() > 0) {
Teller teller = tellersDoingOtherThings.remove();
teller.serveCustomerLine();
workingTellers.offer(teller);
return;
}
// Else create (hire) a new teller
Teller teller = new Teller(customers);
exec.execute(teller);
workingTellers.add(teller);
return;
}
// If line is short enough, remove a teller:
if (workingTellers.size() > 1 && customers.size() / workingTellers.size() < 2)
reassignOneTeller();
// If there is no line, we only need one teller:
if (customers.size() == 0) while (workingTellers.size() > 1) reassignOneTeller();
}
@Override
protected AbstractPlanNode recursivelyApply(AbstractPlanNode planNode) {
assert (planNode != null);
// breadth first:
// find AggregatePlanNode with exactly one child
// where that child is an AbstractScanPlanNode.
// Inline any qualifying AggregatePlanNode to its AbstractScanPlanNode.
Queue<AbstractPlanNode> children = new LinkedList<AbstractPlanNode>();
children.add(planNode);
while (!children.isEmpty()) {
AbstractPlanNode plan = children.remove();
AbstractPlanNode newPlan = inlineAggregationApply(plan);
if (newPlan != plan) {
if (plan == planNode) {
planNode = newPlan;
} else {
planNode.replaceChild(plan, newPlan);
}
}
for (int i = 0; i < newPlan.getChildCount(); i++) {
children.add(newPlan.getChild(i));
}
}
return planNode;
}
