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

The following examples show how to use java.util.Stack#peek() . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: NextGreaterNode_1019.java    From AlgoCS with MIT License 17 votes vote down vote up
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;
}
 
Example 2
Source File: LongestValidParen.java    From LeetCode-Sol-Res with MIT License 6 votes vote down vote up
/**
 * 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;
}
 
Example 3
Source File: QueryBuilder.java    From sherlock with GNU General Public License v3.0 6 votes vote down vote up
/**
 * 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;
}
 
Example 4
Source File: Solution22.java    From learningNote-interview with Apache License 2.0 6 votes vote down vote up
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();
}
 
Example 5
Source File: Solution.java    From codekata with MIT License 6 votes vote down vote up
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;
}
 
Example 6
Source File: TreeNonRecursiveTraversals.java    From big-o with MIT License 6 votes vote down vote up
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;
				}
			}
		}
	}
}
 
Example 7
Source File: Asteroids.java    From LeetCode-Sol-Res with MIT License 6 votes vote down vote up
/**
 * 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;
}
 
Example 8
Source File: RichTextMutationBuilder.java    From swellrt with Apache License 2.0 6 votes vote down vote up
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);
}
 
Example 9
Source File: LongestValidParen.java    From LeetCode-Sol-Res with MIT License 6 votes vote down vote up
/**
 * 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;
}
 
Example 10
Source File: Solution.java    From LeetCode-Solution-in-Good-Style with Apache License 2.0 5 votes vote down vote up
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();
}
 
Example 11
Source File: Tree.java    From joshua with Apache License 2.0 5 votes vote down vote up
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();
  }
}
 
Example 12
Source File: DOM2SAX.java    From hottub with GNU General Public License v2.0 5 votes vote down vote up
/**
 * 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;
}
 
Example 13
Source File: ScriptBuilder.java    From bcm-android with GNU General Public License v3.0 5 votes vote down vote up
/**
 * 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));
}
 
Example 14
Source File: CrackingCodingInterview3.java    From algorithms with MIT License 5 votes vote down vote up
/**
 * 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;
}
 
Example 15
Source File: KitsTrackerImpl.java    From netbeans with Apache License 2.0 5 votes vote down vote up
/**
 * 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
    }
}
 
Example 16
Source File: ViewParser.java    From alfresco-repository with GNU Lesser General Public License v3.0 5 votes vote down vote up
/**
 * 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");
}
 
Example 17
Source File: Question22.java    From offer with Apache License 2.0 5 votes vote down vote up
/**
 * 问题:给定数组为压栈顺序(无重复),判断另一数组是否可能为出栈顺序
 * 思路:建立一个辅助栈,依序遍历压栈序列,若与出栈数不相等,则将该压栈数压入辅助栈,继续遍历压栈数组
 * 若相等则继续遍历入栈序列和出栈序列,当出栈序列与入栈序列和辅助栈序列都不一致时,返回 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; // 当序列一致时,辅助栈为空,入栈序列遍历完成
}
 
Example 18
Source File: Tool.java    From 920-text-editor-v2 with Apache License 2.0 4 votes vote down vote up
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();
}
 
Example 19
Source File: ParseFilter.java    From hbase with Apache License 2.0 4 votes vote down vote up
/**
 * 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;
}
 
Example 20
Source File: ReduceEdges.java    From pegasus with Apache License 2.0 4 votes vote down vote up
/**
 * 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);
    }
}