java.util.Stack Java Examples

private void traverseTree(Stack<BallTreeNode<T>> stack, Stack<Integer> sideStack, BallTreeNode<T> root, double[] values) {
	BallTreeNode<T> currentNode = root;
	stack.push(currentNode);
	while (!currentNode.isLeaf()) {
		if (currentNode.hasTwoChilds()) {
			double distanceLeft = distance.calculateDistance(currentNode.getLeftChild().getCenter(), values);
			double distanceRight = distance.calculateDistance(currentNode.getRightChild().getCenter(), values);
			currentNode = (distanceLeft < distanceRight) ? currentNode.getLeftChild() : currentNode.getRightChild();
			sideStack.push(Double.compare(distanceLeft, distanceRight));
		} else {
			currentNode = currentNode.getChild();
			sideStack.push(0);
		}
		stack.push(currentNode);
	}
	sideStack.push(0);
}
 

/**
 * Declare a mapping of a prefix to namespace URI at the given element depth.
 * @param prefix a String with the prefix for a qualified name
 * @param uri a String with the uri to which the prefix is to map
 * @param elemDepth the depth of current declaration
 */
boolean pushNamespace(String prefix, String uri, int elemDepth)
{
    // Prefixes "xml" and "xmlns" cannot be redefined
    if (prefix.startsWith(XML_PREFIX))
    {
        return false;
    }

    Stack stack;
    // Get the stack that contains URIs for the specified prefix
    if ((stack = (Stack) m_namespaces.get(prefix)) == null)
    {
        m_namespaces.put(prefix, stack = new Stack());
    }

    if (!stack.empty() && uri.equals(((MappingRecord)stack.peek()).m_uri))
    {
        return false;
    }
    MappingRecord map = new MappingRecord(prefix,uri,elemDepth);
    stack.push(map);
    m_nodeStack.push(map);
    return true;
}
 

/**
 * Time Complexity: O(n)
 * Space Complexity: O(n)
 * Runtime: <a href="https://leetcode.com/submissions/detail/248556303/">1 ms</a>.
 * @param root
 * @return
 */
public static int findSecondMinimumValueIterative(TreeNode root) {
    if (root == null || (root.left == null && root.right == null)) return -1;

    int min = root.val;
    long secondMin = Long.MAX_VALUE;

    Stack<TreeNode> stack = new Stack<>();
    stack.push(root);

    while (!stack.empty()) {
        TreeNode node = stack.pop();
        if (node == null) continue;

        if (node.val > min && node.val < secondMin) {
            secondMin = node.val;
        }
        stack.push(node.left);
        stack.push(node.right);
    }

    return secondMin == Long.MAX_VALUE ? -1 : (int) secondMin;
}
 

/**
 * Declare a mapping of a prefix to namespace URI at the given element depth.
 * @param prefix a String with the prefix for a qualified name
 * @param uri a String with the uri to which the prefix is to map
 * @param elemDepth the depth of current declaration
 */
boolean pushNamespace(String prefix, String uri, int elemDepth)
{
    // Prefixes "xml" and "xmlns" cannot be redefined
    if (prefix.startsWith(XML_PREFIX))
    {
        return false;
    }

    Stack stack;
    // Get the stack that contains URIs for the specified prefix
    if ((stack = (Stack) m_namespaces.get(prefix)) == null)
    {
        m_namespaces.put(prefix, stack = new Stack());
    }

    if (!stack.empty() && uri.equals(((MappingRecord)stack.peek()).m_uri))
    {
        return false;
    }
    MappingRecord map = new MappingRecord(prefix,uri,elemDepth);
    stack.push(map);
    m_nodeStack.push(map);
    return true;
}
 

public static Scope findRandomNode(Object rooScopeName, int acceptanceThreshold) {
  ScopeNode root = (ScopeNode) Toothpick.openScope(rooScopeName);
  ScopeNode result = null;
  Stack<ScopeNode> scopeStack = new Stack<>();
  scopeStack.push(root);
  while (result == null && !scopeStack.isEmpty()) {
    ScopeNode scope = scopeStack.pop();
    if (RANDOM.nextInt(RANDOM_INTERVAL_LENGTH) < acceptanceThreshold && scope != root) {
      result = scope;
    } else {
      for (ScopeNode childScope : scope.getChildrenScopes()) {
        scopeStack.push(childScope);
      }
    }
  }
  return result;
}
 

/**
 * Traverse the Tree in post order. Call method in TraverseInterface for every found Node-object.
 *
 * @param traverseInterface method to call.
 */
public void traversePost(TraverseInterface traverseInterface) {
  Stack<Node> stack = new Stack<>();
  HashSet<Node> hash = new HashSet<>();
  Node root = this;
  stack.push(root);
  while (!stack.isEmpty()) {
    root = stack.peek();
    if (root.children.size() == 0 || hash.contains(root)) {
      traverseInterface.traverseMethod(stack.pop());
    } else {
      root.children.forEach(stack::push);
      hash.add(root);
    }
  }
}
 

/**
 * 中序遍历
 * @param root
 */
public void inOrder(TreeNode root) {
    
    Stack<TreeNode> stack = new Stack<>();
    
    if (root == null) {
        return;
    }
    TreeNode currentNode = root;

    while (currentNode != null || !stack.empty()) {
        while (currentNode != null) {
            stack.push(currentNode);
            currentNode = currentNode.left;
        }
        if (!stack.empty()) {
            currentNode = stack.pop();
            System.out.print(currentNode.val + " ");
            currentNode = currentNode.right;
        }
    }
}
 

private static void findCircuits(final Set<Circuit> circuits, final Node node, final Stack<Node> stack) {
    if (stack.contains(node)) {
        final int fromIndex = stack.indexOf(node);
        final int toIndex = stack.size();
        final ArrayList<Node> circularity = new ArrayList<>(stack.subList(fromIndex, toIndex));

        // add ending node to list so a full circuit is shown
        circularity.add(node);

        final Circuit circuit = new Circuit(circularity);

        circuits.add(circuit);

        return;
    }

    stack.push(node);

    for (final Node reference : node.initialReferences) {
        findCircuits(circuits, reference, stack);
    }

    stack.pop();
}
 

/**
 * Start capturing thread's output.
 */
public static void startCapture() {
    CaptureLog log = null;
    if (!reuse.isEmpty()) {
        try {
            log = reuse.pop();
        } catch (EmptyStackException e) {
            log = new CaptureLog();
        }
    } else {
        log = new CaptureLog();
    }
    Stack<CaptureLog> stack = logs.get();
    if (stack == null) {
        stack = new Stack<CaptureLog>();
        logs.set(stack);
    }
    stack.push(log);
}
 

/**
 * This method initializes the namespace object with appropriate stacks
 * and predefines a few prefix/uri pairs which always exist.
 */
private void initNamespaces()
{


    // Define the default namespace (initially maps to "" uri)
    Stack stack;
    m_namespaces.put(EMPTYSTRING, stack = new Stack());
    stack.push(new MappingRecord(EMPTYSTRING,EMPTYSTRING,0));

    m_namespaces.put(XML_PREFIX, stack = new Stack());
    stack.push(new MappingRecord( XML_PREFIX,
        "http://www.w3.org/XML/1998/namespace",0));

    m_nodeStack.push(new MappingRecord(null,null,-1));

}
 

/** function to get all strongly connected components - Tarjan algorithm **/
public List<List<Integer>> getCycles(List<Integer>[] graph) {
    mV = graph.length;
    this.graph = graph;
    low = new int[mV];
    visited = new boolean[mV];
    stack = new Stack<>();
    sccComp = new ArrayList<>();

    for (int v = 0; v < mV; v++) {
        if (!visited[v]) {
            dfs(v);
        }
    }
    return sccComp;

}
 

public void visitScan(SQLBuilderContext ctx, ScanNode scan, Stack<LogicalNode> stack) {

    StringBuilder selectClause = new StringBuilder("SELECT ");
    if (scan.getTargets().size() > 0) {
      selectClause.append(generateTargetList(scan.getTargets()));
    } else {
      selectClause.append("1");
    }

    selectClause.append(" ");

    ctx.sb.append("FROM ").append(scan.getTableName()).append(" ");

    if (scan.hasAlias()) {
      ctx.sb.append("AS ").append(scan.getAlias()).append(" ");
    }

    if (scan.hasQual()) {
      ctx.sb.append("WHERE " + sqlExprGen.generate(scan.getQual()));
    }
  }
 

/**
 * Given an expression and an optional comparator, build a tree of
 * InputFormats using the comparator to sort keys.
 */
static Node parse(String expr, Configuration conf) throws IOException {
  if (null == expr) {
    throw new IOException("Expression is null");
  }
  Class<? extends WritableComparator> cmpcl = conf.getClass(
    CompositeInputFormat.JOIN_COMPARATOR, null, WritableComparator.class);
  Lexer lex = new Lexer(expr);
  Stack<Token> st = new Stack<Token>();
  Token tok;
  while ((tok = lex.next()) != null) {
    if (TType.RPAREN.equals(tok.getType())) {
      st.push(reduce(st, conf));
    } else {
      st.push(tok);
    }
  }
  if (st.size() == 1 && TType.CIF.equals(st.peek().getType())) {
    Node ret = st.pop().getNode();
    if (cmpcl != null) {
      ret.setKeyComparator(cmpcl);
    }
    return ret;
  }
  throw new IOException("Missing ')'");
}
 

private FormatToken wrapLine(FormatContext formatContext, CodeStyle.Holder codeStyle, FormatContext.LineWrap lastWrap,
        int initialIndent, int continuationIndent, Stack<FormatContext.ContinuationBlock> continuations) {
    // we dont have to remove trailing spaces as indentation will fix it
    formatContext.insertWithOffsetDiff(lastWrap.getToken().getOffset()
            + lastWrap.getToken().getText().length(), "\n", lastWrap.getOffsetDiff()); // NOI18N
    // there is + 1 for eol
    formatContext.setCurrentLineStart(lastWrap.getToken().getOffset()
            + lastWrap.getToken().getText().length() + 1 + lastWrap.getOffsetDiff());

    FormatToken indentationEnd = FormatTokenStream.getNextNonWhite(lastWrap.getToken(), false);
    assert indentationEnd != null;

    // do the indentation
    indentLine(lastWrap.getToken(), formatContext, codeStyle, continuations,
            indentationEnd, lastWrap.getToken().getOffset() + lastWrap.getToken().getText().length() + 1,
            initialIndent, IndentUtils.indentLevelSize(formatContext.getDocument()), continuationIndent,
            true, true, Indentation.ALLOWED, lastWrap.getIndentationLevel(), lastWrap.getOffsetDiff());
    formatContext.resetTabCount();
    return indentationEnd;
}
 

@Before
public void setup() {
    conversationCallback = mock(IConversationCallback.class);
    when(conversationCallback.doExternalCall(any(URI.class), any(ConversationDataRequest.class), anyLong())).
            thenAnswer(invocation -> {
                ConversationDataResponse conversationDataResponse = new ConversationDataResponse();
                conversationDataResponse.setHttpCode(200);
                return conversationDataResponse;
            });
    memory = mock(IConversationMemory.class);
    IConversationMemory.IWritableConversationStep currentStep = mock(IConversationMemory.IWritableConversationStep.class);
    when(memory.getCurrentStep()).thenAnswer(invocation -> currentStep);
    when(memory.getRedoCache()).thenAnswer(invocation -> new Stack<>());
    when(memory.getAllSteps()).thenAnswer(invocation ->
            new ConversationMemory.ConversationStepStack(new LinkedList<>()));
    when(currentStep.getLatestData(eq("actions"))).thenAnswer(invocation ->
            new Data<>("actions", Collections.singletonList("action_1")));
    when(memory.getConversationProperties()).thenAnswer(invocation -> new ConversationProperties(memory));
}
 

public List<Integer> preorderTraversal(TreeNode root) {

        ArrayList<Integer> res = new ArrayList<Integer>();
        if(root == null)
            return res;

        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.empty()){
            TreeNode curNode = stack.pop();
            res.add(curNode.val);

            if(curNode.right != null)
                stack.push(curNode.right);
            if(curNode.left != null)
                stack.push(curNode.left);
        }
        return res;
    }
 

/**
 * Return stack of moves from initial state that leads to this final state
 *  
 * @param n  Final State
 */
public static Stack<IMove> computeSolution(INode n) {
	Stack<IMove> res = new Stack<IMove>();
	System.out.println(n);
	Chain ch = (Chain) n.storedData();
	if (ch == null) {
		return res;
	}
	
	// must reverse the chain
	Stack<Chain> chainStack = new Stack<Chain>();
	while (ch != null) {
		chainStack.push(ch);
		ch = ch.previous;
	}
	
	while (!chainStack.isEmpty()) {
		ch = chainStack.pop();
		for (Iterator<IMove> it = ch.moves.iterator(); it.hasNext(); ) {
			res.push(it.next());
		}
	}
	
	return res;
}
 

public void execute(ExecutionContext context)
{
    Stack<Object> stack = context.getStack();
    int n = ((Number)stack.pop()).intValue();
    if (n > 0)
    {
        int size = stack.size();
        //Need to copy to a new list to avoid ConcurrentModificationException
        List<Object> copy = new java.util.ArrayList<Object>(
                stack.subList(size - n, size));
        stack.addAll(copy);
    }
}
 

/**
 * 添加Activity到堆栈
 */
public void addActivity(Activity activity) {
    if (activityStack == null) {
        activityStack = new Stack<Activity>();
    }
    activityStack.add(activity);
}
 

public FixedHeightLayoutCache() {
    super();
    tempStacks = new Stack<Stack<TreePath>>();
    boundsBuffer = new Rectangle();
    treePathMapping = new Hashtable<TreePath, FHTreeStateNode>();
    info = new SearchInfo();
    setRowHeight(1);
}
 

protected File[] crawlFiles(File dirRoot, boolean recur,
    boolean crawlForDirs) {
  if (dirRoot == null || ((!dirRoot.exists()))) {
    throw new IllegalArgumentException("dir root: [" + dirRoot
                                       + "] is null or non existant!");
  }

  List<File> fileList = new Vector<File>();

  // start crawling
  Stack<File> stack = new Stack<File>();
  stack.push(dirRoot.isDirectory() ? dirRoot : dirRoot.getParentFile());
  while (!stack.isEmpty()) {
    File dir = (File) stack.pop();
    LOG.log(Level.INFO, "OFSN: Crawling " + dir);

    File[] productFiles;
    productFiles = crawlForDirs ? dir.listFiles(DIR_FILTER) : dir.listFiles(FILE_FILTER);

    if(productFiles!=null) {
      Collections.addAll(fileList, productFiles);
    }
    if (recur) {
      File[] subdirs = dir.listFiles(DIR_FILTER);
      if (subdirs != null) {
        for (File subdir : subdirs) {
          stack.push(subdir);
        }
      }
    }
  }

  return fileList.toArray(new File[fileList.size()]);
}
 

public static void removeAbstractScriptLanguageMgmt() {

		Stack<AbstractScriptLanguageMgmt> abstractScriptLanguageMgmts = getStack(abstractScriptLanguageMgmtThreadLocal);

		for (int i = 0; i < abstractScriptLanguageMgmts.size(); i++) {
			abstractScriptLanguageMgmts.get(i).close();
		}
		abstractScriptLanguageMgmts.clear();
	}
 

/**
 * Add a new Resource with this id.
 * 
 * @param container
 *        The container for this resource.
 * @param id
 *        The id.
 * @param others
 *        Other fields for the newResource call
 * @return The locked Resource object with this id, or null if the id is in use.
 */
public Edit putResource(Entity container, String id, Object[] others)
{
	// create one with just the id, and perhaps some other fields, too
	Entity entry = m_user.newResource(container, id, others);

	// form the XML and SQL for the insert
	Document doc = StorageUtils.createDocument();
	entry.toXml(doc, new Stack());
	String xml = StorageUtils.writeDocumentToString(doc);

	String statement = doubleStorageSql.getInsertSql3(m_resourceTableName, insertFields(m_containerTableIdField, m_resourceTableIdField,
			m_resourceTableOtherFields, "XML"), valuesParams(m_resourceTableOtherFields));
	Object[] flds = m_user.storageFields(entry);

	if (flds == null) flds = new Object[0];
	Object[] fields = new Object[flds.length + 3];
	System.arraycopy(flds, 0, fields, 2, flds.length);
	fields[0] = container.getReference();
	fields[1] = entry.getId();
	fields[fields.length - 1] = xml;

	// process the insert
	boolean ok = m_sql.dbWrite(statement, fields);

	// if this failed, assume a key conflict (i.e. id in use)
	if (!ok) return null;

	// now get a lock on the record for edit
	Edit edit = editResource(container, id);
	if (edit == null)
	{
		log.warn("putResource(): didn't get a lock!");
		return null;
	}

	return edit;
}
 

public static AbstractScriptLanguageMgmt getAbstractScriptLanguageMgmt() {
	Stack<AbstractScriptLanguageMgmt> stack = getStack(abstractScriptLanguageMgmtThreadLocal);
	if (stack.isEmpty()) {
		return null;
	}
	return stack.peek();
}
 

private static void runIf(final Stack stack, final PostfixMathCommandI pCommand)
{
    try
    {
        pCommand.run(stack);
    }
    catch (ParseException ignored)
    {
    }
}
 

public Stack<Value> copyStack(){
	Stack<Value> ret = new Stack<Value>();
	//soft copy is fine
	ret.addAll(stack);
	
	return ret;
}
 

/**
 * Creates a parser instance.
 * @param handler handler interface implementation (never <code>null</code>
 * It is recommended that it could be able to resolve at least the [email protected] parslet convertors implementation (never <code>null</code>
 *
 */
public LibraryDeclarationParser(final LibraryDeclarationHandler handler, final LibraryDeclarationConvertor parslet) {
    this.parslet = parslet;
    this.handler = handler;
    buffer = new StringBuffer(111);
    context = new Stack<Object[]>();
}
 

/**
 * Return the currently mapped namespace URI for the specified prefix,
 * if any; otherwise return <code>null</code>.  These mappings come and
 * go dynamically as the document is parsed.
 *
 * @param prefix Prefix to look up
 */
public String findNamespaceURI(String prefix) {
    
    Stack<String> nsStack = namespaces.get(prefix);
    if (nsStack == null) {
        return null;
    }
    try {
        return (nsStack.peek());
    } catch (EmptyStackException e) {
        return null;
    }

}
 

/**
 * Re-do the last undone operation for a specific rich text editor
 *
 * @param editor Re-do an operation for this rich text editor
 */
synchronized void redo(RTEditText editor) {
    Stack<Operation> redoStack = getRedoStack(editor);
    if (!redoStack.empty()) {
        Stack<Operation> undoStack = getUndoStack(editor);
        Operation op = redoStack.pop();
        push(op, undoStack);
        op.redo(editor);
        while (!redoStack.empty() && op.canMerge(redoStack.peek())) {
            op = redoStack.pop();
            push(op, undoStack);
            op.redo(editor);
        }
    }
}
 

private void migrate2(File dataDir, Stack<Integer> versions) {
	for (File file: dataDir.listFiles()) {
		if (file.getName().startsWith("Depots.xml")) {
			VersionedXmlDoc dom = VersionedXmlDoc.fromFile(file);
			for (Element element: dom.getRootElement().elements()) {
				Element gateKeeperElement = element.element("gateKeeper");
				gateKeeperElement.detach();
				element.addElement("gateKeepers");
			}
			dom.writeToFile(file, false);
		}
	}	
}