Stack — 20181121

12. Min Stack

 public class MinStack {
     Stack<Integer> stack;
     Stack<Integer> minStack;

     public MinStack() {
         // do intialization if necessary
         stack = new Stack<>();
         minStack = new Stack<>();
     }

     /*
      * @param number: An integer
      * @return: nothing
      */
     public void push(int number) {
         // write your code here
         stack.push(number);
         if (minStack.isEmpty()) {
             minStack.push(number);
         } else {
             minStack.push(Math.min(minStack.peek(), number));
         }
     }

     /*
      * @return: An integer
      */
     public int pop() {
         // write your code here
         minStack.pop();
         return stack.pop();
     }

     /*
      * @return: An integer
      */
     public int min() {
         // write your code here
         return minStack.peek();
     }
 }

575. Decode String

 public class Solution {
     /**
      * @param s: an expression includes numbers, letters and brackets
      * @return: a string
      */
     public String expressionExpand(String s) {
         // write your code here
         if (s == null || s.length() == 0) {
             return s;
         }
         String res = "";
         Stack<String> stack = new Stack<>();
         for (int i = 0; i < s.length(); i++) {
             stack.push(s.substring(i, i + 1));
             if (stack.peek().equals("]")) {
                 stack.pop();
                 String str = "";
                 String totalStr = "";
                 while (!stack.isEmpty() && !stack.peek().equals("[")) {
                     str = stack.pop() + str;
                 }
                 stack.pop();
                 int base = 1;
                 int num = 0;
                 while (!stack.isEmpty() && getNum(stack.peek()) >= 0) {
                     num += base * (getNum(stack.pop()));
                     base *= 10;
                 }
                 for (int j = 0; j < num; j++) {
                     totalStr += str;
                 }
                 if(!totalStr.equals("")){
                     stack.push(totalStr);
                 }
             }
         }
         while (!stack.isEmpty()) {
             res = stack.pop() + res;
         }
         return res;
     }

     public int getNum(String s) {
         char c = s.charAt(0);
         if (c < '0' || c > '9') {
             return -1;
         }
         return c - '0';
     }
 }

单调栈

122. Largest Rectangle in Histogram

 public class Solution {
     /**
      * @param height: A list of integer
      * @return: The area of largest rectangle in the histogram
      */
     public int largestRectangleArea(int[] height) {
         // write your code here
         if (height == null || height.length == 0) {
             return 0;
         }
         Stack<Integer> stack = new Stack<>();
         int res = 0;
         for (int i = 0; i <= height.length; i++) {
             int cur = i == height.length ? -1 : height[i];
             if (stack.isEmpty()) {
                 stack.push(i);
                 continue;
             }

             while (!stack.isEmpty() && cur <= height[stack.peek()]) {
                 int h = height[stack.pop()];
                 int w = stack.isEmpty() ? i : i - stack.peek() -1;
                 res = Math.max(res, h * w);
             }
             stack.push(i);
         }
         return res;
     }
 }

510. Maximal Rectangle

 public class Solution {
     /**
      * @param matrix: a boolean 2D matrix
      * @return: an integer
      */
     public int maximalRectangle(boolean[][] matrix) {
         // write your code here
         if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
             return 0;
         }
         int r = matrix.length;
         int c = matrix[0].length;

         int[][] height = new int[r][c + 1];
         for (int i = 0; i < r; i++) {
             for (int j = 0; j <= c; j++) {
                 if (j == c) {
                     height[i][j] = -1;
                     continue;
                 }
                 if (i == 0) {
                     height[i][j] = matrix[i][j] ? 1 : 0;
                     continue;
                 }
                 height[i][j] = !matrix[i][j] ? 0 : height[i - 1][j] + 1;
             }
         }
         int res = 0;
         for (int i = 0; i < height.length; i++) {
             res = Math.max(res, getMaxRecTangle(height[i]));
         }
         return res;
     }

     public int getMaxRecTangle(int[] height) {
         if (height == null || height.length == 0) {
             return 0;
         }

         Stack<Integer> stack = new Stack<>();
         int res = 0;
         for (int i = 0; i < height.length; i++) {
             if (stack.isEmpty()) {
                 stack.push(i);
                 continue;
             }
             while (!stack.isEmpty() && height[i] <= height[stack.peek()]) {
                 int h = height[stack.pop()];
                 int w = stack.isEmpty() ? i : i - stack.peek() - 1;
                 res = Math.max(res, h * w);
             }
             stack.push(i);
         }
         return res;
     }
 }

126. Max Tree

 /**
  * Definition of TreeNode:
  * public class TreeNode {
  *     public int val;
  *     public TreeNode left, right;
  *     public TreeNode(int val) {
  *         this.val = val;
  *         this.left = this.right = null;
  *     }
  * }
  */

 public class Solution {
     /**
      * @param A: Given an integer array with no duplicates.
      * @return: The root of max tree.
      */
     public TreeNode maxTree(int[] A) {
         // write your code here
         TreeNode root = null;
         if (A == null || A.length == 0) {
             return root;
         }
         Stack<TreeNode> stack = new Stack<>();
         for (int i = 0; i <= A.length; i++) {
             TreeNode right = i == A.length ? new TreeNode(Integer.MAX_VALUE) : new TreeNode(A[i]);
             if (stack.isEmpty()) {
                 stack.push(right);
                 continue;
             }
             while (!stack.isEmpty() && right.val > stack.peek().val) {
                 TreeNode node = stack.pop();
                 if (stack.isEmpty()) {
                     right.left = node;
                     break;
                 }
                 TreeNode left = stack.peek();
                 if (left.val < right.val) {
                     left.right = node;
                 } else {
                     right.left = node;
                 }
             }
             stack.push(right);
         }
         return stack.peek().left;
     }
 }