Java Code Examples for java.util.Stack#peek()

public int[] nextLargerNodes(ListNode head) {
    List<Integer> list = new ArrayList<>();
    while (head != null) {
        list.add(head.val);
        head = head.next;
    }

    int[] res = new int[list.size()];
    Stack<Integer> st = new Stack<>();
    for (int i = list.size() - 1; i >= 0; i--) {
        int num = list.get(i);
        while (!st.isEmpty() && st.peek() <= num) st.pop();
        if (st.isEmpty()) res[i] = 0;
        else res[i] = st.peek();
        st.push(num);
    }
    return res;
}
 

/**
 * DP
 */
public int longestValidParenthesesB(String s) {
    if (s == null || s.length() == 0) return 0;

    Stack<Integer> stack = new Stack<>(); // Save indices of '('
    int[] dp = new int[s.length()]; // Store the length of the current longest valid sequence.

    int max = 0;
    for (int i = 0; i < s.length(); i++) {
        if (s.charAt(i) == '(') stack.push(i);  
        else if (stack.isEmpty()) continue;
        else if (stack.peek() > 0) 
            dp[i] = 2 + dp[stack.pop() - 1] + dp[i - 1]; // connect two valid sequences, or increase the length of current valid sequence. 
        else {
            dp[i] = 2 + dp[i - 1]; // leftmost char is a '('
            stack.pop();
        }
        max = Math.max(dp[i], max);
    }
    return max;
}
 

/**
 * Find the start and end position of the phase 2 query, if it exists,
 * in the query string. Also performs basic JSON syntax validation.
 *
 * @return true if the query is valid, false otherwise
 */
protected boolean findQueryPosition() {
    Stack<Integer> stack = new Stack<>();
    char[] chars = queryString.toCharArray();
    for (int i = 0; i < chars.length; i++) {
        char c = chars[i];
        if (c != '{' && c != '}') {
            continue;
        }
        if (c == '{') {
            stack.push(i);
            continue;
        }
        if (!stack.empty()) {
            queryStartPos = stack.peek();
            queryEndPos = i + 1;
            stack.pop();
        } else {
            return false;
        }
    }
    return queryStartPos != null && queryEndPos != null;
}
 

public boolean IsPopOrder(int[] pushA, int[] popA) {
    //特殊情况序列为零的判断：
    if (pushA.length == 0 || popA.length == 0) return false;
    Stack <Integer> stack = new Stack <Integer>();
    //用于标识弹出序列的位置
    int index = 0;
    for (int i = 0; i < pushA.length; i++) {
        stack.push( pushA[i] );
        while (!stack.isEmpty() && stack.peek() == popA[index]) {
            //出栈
            stack.pop();
            //弹出序列向后一位a
            index++;
        }
    }
    return  stack.isEmpty();
}
 

public int[] nextGreaterElements(int[] nums) {
    Stack<Integer> stack = new Stack<>();
    int len = nums.length, result[] = new int[len];

    for (int i = 0; i < len; i++) {
        while (!stack.empty() && nums[stack.peek()] < nums[i]) {
            result[stack.pop()] = nums[i];
        }
        stack.add(i);
    }

    for (int num : nums) {
        while (!stack.empty() && nums[stack.peek()] < num) {
            result[stack.pop()] = num;
        }
    }

    while (!stack.empty()) result[stack.pop()] = -1;

    return result;
}
 

public static void traversePreorder(TreeNode<?> rootNode) {
	if (rootNode == null) {
		return;
	}

	Stack<TreeNode<?>> stack = new Stack<TreeNode<?>>();
	stack.push(rootNode);
	while (!stack.empty()) {
		TreeNode<?> current = stack.peek();
		System.out.println(current);
		if (current.hasLeft()) {
			stack.push(current.getLeft());
		} else {
			// Pop until we have a node with a right sub-tree.
			while (!stack.empty()) {
				current = stack.pop();
				if (current.hasRight()) {
					stack.push(current.getRight());
					break;
				}
			}
		}
	}
}
 

/**
 * Directly using java.util.stack.
 * Not recommended since stack has been deprecated.
 * Create a stack to deal with collisions.
 * For each asteroids, ast:
 * | Check if there is a collision, when stack is not empty, and asteroid size < 0, and previous asteroid > 0
 * |   If yes, compare asteroids' sizes:
 * |     If ast is larger, pop previous asteroid from stack, continue comparison with the next stack top.
 * |     If ast is the same size, just pop since both asteroids are destroyed. Then continue to next asteroid.
 * |     If ast is smaller, it's destroyed. Continue to next asteroid.
 * |   If no, push the current asteroid to the stack and continue to next asteroid.
 * After all asteroids are done, convert the resulting stack to an array.
 */
public int[] asteroidCollision2(int[] asteroids) {
    Stack<Integer> stack = new Stack<>();
    for (int ast : asteroids) {
        while (!stack.isEmpty() && ast < 0 && 0 < stack.peek()) {
            if (stack.peek() < -ast) {
                stack.pop();
                continue;
            } else if (stack.peek() == -ast) {
                stack.pop();
            }
            break;
        }
        stack.push(ast);
    }

    int[] ans = new int[stack.size()];
    for (int t = ans.length - 1; t >= 0; --t) {
        ans[t] = stack.pop();
    }
    return ans;
}
 

private void startAnnotation(Nindo.Builder builder, String annotationKey,
    String annotationValue) {
  Stack<String> annotationStack = startedAnnotations.get(annotationKey);
  if (annotationStack == null) {
    annotationStack = new Stack<String>();
    startedAnnotations.put(annotationKey, annotationStack);
    affectedKeys.add(annotationKey);
  }
  String current = annotationStack.isEmpty() ? null : annotationStack.peek();
  // Avoid no-ops
  if (ValueUtils.notEqual(annotationValue, current)) {
    if (current == null && isDefaultValue(annotationKey, annotationValue)) {
      // If the current annotation is the default, and the new annotation
      // value is also the default, we don't need to set the annotation value
    } else {
      builder.startAnnotation(annotationKey, annotationValue);
    }
  }
  annotationStack.push(annotationValue);
}
 

/**
 * Optimized DP
 * Build a stack for indices of open parentheses
 * Traverse the string, if current is open paren, push to stack
 * Otherwise, its close paren. 
 * If stack is empty, no open paren left, reset len to 0.
 * If not, pop the index from stack, matchedLen = current index - index of 
 * pop open paren + 1
 * If stack is empty, means this matchedLen can be added to the whole len
 * If not, 
 */
public static int longestValidParentheses(String s) {
    if (s == null) return 0;
    Stack<Integer> stack = new Stack<Integer>();
    int maxLen = 0;
    int len = 0;

    for (int i = 0; i < s.length(); i++) {
        if (s.charAt(i) == '(') stack.push(i);
        else if (s.isEmpty()) len = 0;
        else {
            int matchedPos = stack.pop();
            int matchedLen = i - matchedPos + 1;
            if (s.isEmpty()) { // ()()
                len += matchedLen;
                matchedLen = len;
            } else matchedLen = i - stack.peek(); // ()(()()
            maxLen = Math.max(maxLen, matchedLen);
        }
    }
    return maxLen;
}
 

public boolean validateStackSequences(int[] pushed, int[] popped) {
    int len1 = pushed.length;
    int len2 = popped.length;

    if (len1 == 0 && len2 == 0){
        return true;
    }

    if (len2 == 0 || len1 != len2) {
        return false;
    }

    int index = 0;
    Stack<Integer> stack = new Stack<>();
    for (int i = 0; i < len1; i++) {
        stack.push(pushed[i]);

        while (!stack.isEmpty() && stack.peek() == popped[index]) {
            stack.pop();
            index++;
        }

        // 调试代码
        // System.out.println(stack);
    }
    return stack.isEmpty();
}
 

private void initialize(String [] tokens) {
  final Stack<Integer> stack = new Stack<>();
  int nodeIndex = 0;
  for (String token : tokens) {
    final Matcher matcher = NONTERMINAL_PATTERN.matcher(token);
    if (matcher.matches()) {
      // new non-terminal node
      labels[nodeIndex] = matcher.group(1);
      sourceStartIndices[nodeIndex] = Integer.parseInt(matcher.group(2));
      sourceEndIndices[nodeIndex] = Integer.parseInt(matcher.group(3));
      stack.push(nodeIndex);
      nodeIndex++;
    } else if (token.equals(")")) {
      // finished a subtree
      stack.pop();
      if (stack.empty()) {
        break;
      } else {
        numChildren[stack.peek()]++;
      }
    } else {
      // otherwise, it's a new leaf node
      labels[nodeIndex] = token;
      sourceStartIndices[nodeIndex] = -1;
      sourceEndIndices[nodeIndex] = -1;
      numChildren[stack.peek()]++;
      nodeIndex++;
    }
  }
  if (!stack.empty()) {
    // Not enough close-parentheses at the end of the tree.
    throw new IllegalArgumentException();
  }
}
 

/**
 * Begin the scope of namespace prefix. Forward the event to the
 * SAX handler only if the prefix is unknown or it is mapped to a
 * different URI.
 */
private boolean startPrefixMapping(String prefix, String uri)
    throws SAXException
{
    boolean pushed = true;
    Stack uriStack = _nsPrefixes.get(prefix);

    if (uriStack != null) {
        if (uriStack.isEmpty()) {
            _sax.startPrefixMapping(prefix, uri);
            uriStack.push(uri);
        }
        else {
            final String lastUri = (String) uriStack.peek();
            if (!lastUri.equals(uri)) {
                _sax.startPrefixMapping(prefix, uri);
                uriStack.push(uri);
            }
            else {
                pushed = false;
            }
        }
    }
    else {
        _sax.startPrefixMapping(prefix, uri);
        _nsPrefixes.put(prefix, uriStack = new Stack());
        uriStack.push(uri);
    }
    return pushed;
}
 

/**
 * Adds the given number as a push data chunk to the given index in the program.
 * This is intended to use for negative numbers or values greater than 16, and although
 * it will accept numbers in the range 0-16 inclusive, the encoding would be
 * considered non-standard.
 *
 * @see #number(long)
 */
protected ScriptBuilder bigNum(int index, long num) {
    final byte[] data;

    if (num == 0) {
        data = new byte[0];
    } else {
        Stack<Byte> result = new Stack<>();
        final boolean neg = num < 0;
        long absvalue = Math.abs(num);

        while (absvalue != 0) {
            result.push((byte) (absvalue & 0xff));
            absvalue >>= 8;
        }

        if ((result.peek() & 0x80) != 0) {
            // The most significant byte is >= 0x80, so push an extra byte that
            // contains just the sign of the value.
            result.push((byte) (neg ? 0x80 : 0));
        } else if (neg) {
            // The most significant byte is < 0x80 and the value is negative,
            // set the sign bit so it is subtracted and interpreted as a
            // negative when converting back to an integral.
            result.push((byte) (result.pop() | 0x80));
        }

        data = new byte[result.size()];
        for (int byteIdx = 0; byteIdx < data.length; byteIdx++) {
            data[byteIdx] = result.get(byteIdx);
        }
    }

    // At most the encoded value could take up to 8 bytes, so we don't need
    // to use OP_PUSHDATA opcodes
    return addChunk(index, new ScriptChunk(data.length, data));
}
 

/**
 * 3.6 Sort Stack using peek, pop, push, isEmpty. O(n^2) time no extra memory.
 */
public static Stack<Integer> sort(Stack<Integer> source) {
    Stack<Integer> result = new Stack<Integer>();
    while (!source.isEmpty()) {
        Integer el = source.pop();
        while (!result.isEmpty() && result.peek() < el) {
            source.push(result.pop());
        }
        result.push(el);
    }
    return result;
}
 

/**
 * Find mime type for a given editor kit implementation class.
 * 
 * @param kitClass The editor kit class to get the mime type for.
 * @return The mime type or <code>null</code> if the mime type can't be
 *   resolved for the given kit class.
 */
public String findMimeType(Class kitClass) {
    if (kitClass != null) {
        if (WELL_KNOWN_PARENTS.contains(kitClass.getName())) {
            // these classes are not directly registered as a kit for any mime type
            return null;
        }

        String contextMimeType = null;
        Stack<String> context = contexts.get();
        if (context != null && !context.empty()) {
            contextMimeType = context.peek();
        }
        
        if (contextMimeType == null || contextMimeType.length() == 0) {
            List mimeTypes = getMimeTypesForKitClass(kitClass);
            if (mimeTypes.size() == 0) {
                if (LOG.isLoggable(Level.WARNING) && !DYNAMIC_LANGUAGES.contains(kitClass.getName())) {
                    logOnce(Level.WARNING, "No mime type uses editor kit implementation class: " + kitClass); //NOI18N
                }
                return null;
            } else if (mimeTypes.size() == 1) {
                return (String) mimeTypes.get(0);
            } else {
                if (LOG.isLoggable(Level.WARNING)) {
    //                Throwable t = new Throwable("Stacktrace"); //NOI18N
    //                LOG.log(Level.WARNING, "Ambiguous mime types for editor kit implementation class: " + kitClass + "; mime types: " + mimeTypes, t); //NOI18N
                    logOnce(Level.WARNING, "Ambiguous mime types for editor kit implementation class: " + kitClass + "; mime types: " + mimeTypes); //NOI18N
                }
                return null;
            }
        } else{
            return contextMimeType;
        }
    } else {
        return ""; //NOI18N
    }
}
 

/**
 * Get parent Node Context
 * 
 * @param contextStack  context stack
 * @return  node context
 */
private NodeContext peekNodeContext(Stack<ElementContext> contextStack)
{
    ElementContext element = contextStack.peek();
    if (element instanceof NodeContext)
    {
        return (NodeContext)element;
    }
    else if (element instanceof NodeItemContext)
    {
        return ((NodeItemContext)element).getNodeContext();
    }
    throw new ImporterException("Internal error: Failed to retrieve node context");
}
 

/**
 * 问题：给定数组为压栈顺序（无重复），判断另一数组是否可能为出栈顺序
 * 思路：建立一个辅助栈，依序遍历压栈序列，若与出栈数不相等，则将该压栈数压入辅助栈，继续遍历压栈数组
 * 若相等则继续遍历入栈序列和出栈序列，当出栈序列与入栈序列和辅助栈序列都不一致时，返回 false
 * 若辅助栈空，且入栈序列遍历完毕则返回 true
 * @param pushOrder
 * @param popOrder
 * @return
 */
public boolean isPopOrder(int[] pushOrder,int[] popOrder){
    // 出栈、入栈序列为空或长度不相等，则返回 false
    if (pushOrder == null || popOrder == null||pushOrder.length!=popOrder.length) {
        return false;
    }
    Stack<Integer> stack = new Stack<>();
    int pushIndex = 0,
            popIndex = 0,
            len=pushOrder.length;
    while (popIndex < len) {
        if (pushIndex<len&&pushOrder[pushIndex] == popOrder[popIndex]) { // 入栈出栈序列一致，继续遍历下一个
            popIndex++;
            pushIndex++;
        }
        // 辅助栈顺序与出栈序列一致，辅助栈出栈，继续遍历下一个
        else if (stack.size() != 0 && stack.peek() == popOrder[popIndex]) {
            popIndex++;
            stack.pop();
        }
        // 入栈序列遍历结束且辅助栈顺序与出栈序列不一致，直接返回 false
        else if (pushIndex >= len && stack.peek() != popOrder[popIndex]) {
            return false;
        }
        // 压入辅助装，继续寻找下一相同序列
        else {
            stack.push(pushOrder[pushIndex]);
            pushIndex++;
        }
    }
    return stack.size()==0&&pushIndex==len; // 当序列一致时，辅助栈为空，入栈序列遍历完成
}
 

public static String globToRE(String glob) {
    if (glob.startsWith("(re)")) {
        return glob.substring(4);
    }

    final Object NEG = new Object();
    final Object GROUP = new Object();
    Stack<Object> state = new Stack<Object>();

    StringBuilder buf = new StringBuilder();
    boolean backslash = false;

    int length = glob.length();
    for (int i = 0; i < length; i++) {
        char c = glob.charAt(i);
        if (backslash) {
            buf.append('\\');
            buf.append(c);
            backslash = false;
            continue;
        }

        switch (c) {
            case '\\':
                backslash = true;
                break;
            case '?':
                buf.append('.');
                break;
            case '.':
            case '+':
            case '(':
            case ')':
                buf.append('\\');
                buf.append(c);
                break;
            case '*':
                buf.append(".*");
                break;
            case '|':
                if (backslash)
                    buf.append("\\|");
                else
                    buf.append('|');
                break;
            case '{':
                buf.append('(');
                if (i + 1 != length && glob.charAt(i + 1) == '!') {
                    buf.append('?');
                    state.push(NEG);
                } else
                    state.push(GROUP);
                break;
            case ',':
                if (!state.isEmpty() && state.peek() == GROUP)
                    buf.append('|');
                else
                    buf.append(',');
                break;
            case '}':
                if (!state.isEmpty()) {
                    buf.append(')');
                    if (state.pop() == NEG)
                        buf.append(".*");
                } else
                    buf.append('}');
                break;
            default:
                buf.append(c);
        }
    }

    return buf.toString();
}
 

/**
 * Parses the filterString and constructs a filter using it
 * <p>
 * @param filterStringAsByteArray filter string given by the user
 * @return filter object we constructed
 */
public Filter parseFilterString (byte [] filterStringAsByteArray)
  throws CharacterCodingException {
  // stack for the operators and parenthesis
  Stack <ByteBuffer> operatorStack = new Stack<>();
  // stack for the filter objects
  Stack <Filter> filterStack = new Stack<>();

  Filter filter = null;
  for (int i=0; i<filterStringAsByteArray.length; i++) {
    if (filterStringAsByteArray[i] == ParseConstants.LPAREN) {
      // LPAREN found
      operatorStack.push(ParseConstants.LPAREN_BUFFER);
    } else if (filterStringAsByteArray[i] == ParseConstants.WHITESPACE ||
               filterStringAsByteArray[i] == ParseConstants.TAB) {
      // WHITESPACE or TAB found
      continue;
    } else if (checkForOr(filterStringAsByteArray, i)) {
      // OR found
      i += ParseConstants.OR_ARRAY.length - 1;
      reduce(operatorStack, filterStack, ParseConstants.OR_BUFFER);
      operatorStack.push(ParseConstants.OR_BUFFER);
    } else if (checkForAnd(filterStringAsByteArray, i)) {
      // AND found
      i += ParseConstants.AND_ARRAY.length - 1;
      reduce(operatorStack, filterStack, ParseConstants.AND_BUFFER);
      operatorStack.push(ParseConstants.AND_BUFFER);
    } else if (checkForSkip(filterStringAsByteArray, i)) {
      // SKIP found
      i += ParseConstants.SKIP_ARRAY.length - 1;
      reduce(operatorStack, filterStack, ParseConstants.SKIP_BUFFER);
      operatorStack.push(ParseConstants.SKIP_BUFFER);
    } else if (checkForWhile(filterStringAsByteArray, i)) {
      // WHILE found
      i += ParseConstants.WHILE_ARRAY.length - 1;
      reduce(operatorStack, filterStack, ParseConstants.WHILE_BUFFER);
      operatorStack.push(ParseConstants.WHILE_BUFFER);
    } else if (filterStringAsByteArray[i] == ParseConstants.RPAREN) {
      // RPAREN found
      if (operatorStack.empty()) {
        throw new IllegalArgumentException("Mismatched parenthesis");
      }
      ByteBuffer argumentOnTopOfStack = operatorStack.peek();
      if (argumentOnTopOfStack.equals(ParseConstants.LPAREN_BUFFER)) {
        operatorStack.pop();
        continue;
      }
      while (!(argumentOnTopOfStack.equals(ParseConstants.LPAREN_BUFFER))) {
        filterStack.push(popArguments(operatorStack, filterStack));
        if (operatorStack.empty()) {
          throw new IllegalArgumentException("Mismatched parenthesis");
        }
        argumentOnTopOfStack = operatorStack.pop();
      }
    } else {
      // SimpleFilterExpression found
      byte [] filterSimpleExpression = extractFilterSimpleExpression(filterStringAsByteArray, i);
      i+= (filterSimpleExpression.length - 1);
      filter = parseSimpleFilterExpression(filterSimpleExpression);
      filterStack.push(filter);
    }
  }

  // Finished parsing filterString
  while (!operatorStack.empty()) {
    filterStack.push(popArguments(operatorStack, filterStack));
  }
  if (filterStack.empty()) {
      throw new IllegalArgumentException("Incorrect Filter String");
  }
  filter = filterStack.pop();
  if (!filterStack.empty()) {
    throw new IllegalArgumentException("Incorrect Filter String");
  }
  return filter;
}
 

/**
 * Prunes redundant edges from the workflow.
 *
 * @param workflow
 * @param root the root from which to start to assign the levels
 * @return the workflow with non essential edges removed
 */
public void assignLevels(Graph workflow, GraphNode root) {
    // start a DFS for the graph at root.

    reset(workflow);
    // mCurrentDepth = 0;
    root.setDepth(0);
    root.setColor(GraphNode.GRAY_COLOR);
    // System.out.println( "Traversing node " + root.getID() );

    // start an iterative DFS on the root
    Stack<GraphNode> stack = new Stack();
    stack.push(root);
    while (!stack.isEmpty()) {
        GraphNode top = stack.peek();
        int newDepth = top.getDepth() + 1;

        for (GraphNode child : top.getChildren()) {
            // we always update the depth to max of current and new depth
            child.setDepth(Math.max(child.getDepth(), newDepth));

            if (child.isColor(GraphNode.WHITE_COLOR)) {
                child.setColor(GraphNode.GRAY_COLOR);
                // System.out.println( "Traversing node " + child.getID() + " with depth " +
                // child.getDepth());

                stack.push(child);
            }
        }

        // set the color of the node to be black
        top.setColor(GraphNode.BLACK_COLOR);
        stack.pop();
    }

    // reset colors again to white
    // sanity intialization of all nodes depth
    for (Iterator it = workflow.nodeIterator(); it.hasNext(); ) {
        GraphNode node = (GraphNode) it.next();
        node.setColor(GraphNode.WHITE_COLOR);
    }
}