比较含退格的字符串">比较含退格的字符串
- 重点总结
  - 1. 使用堆栈思想解决问题
  - 2. 使用StringBuffer(慢但是线程安全)和StringBuilder(快但是不是线程安全的)
  - https://blog.csdn.net/u014570939/article/details/85482349">3.遍历字符串的方法。使用charAt()，subString，toCharArray等 https://blog.csdn.net/u014570939/article/details/85482349
整理字符串
- 重点总结
  - 1. 使用StringBuffer(慢但是线程安全)和StringBuilder(快但是不是线程安全的)
  - https://blog.csdn.net/u014570939/article/details/85482349">2.遍历字符串的方法。使用charAt()，subString，toCharArray等 https://blog.csdn.net/u014570939/article/details/85482349
- 遍历字符串的方法
删除最外层的括号
- 重点总结
  - 1、理解题意，题目是将括号拆分成A+B+…的形式，然后去掉最外层的括号即可
  - 2、熟练StringBuilder和StringBuffer的用法:StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。StringBuilder与其基本相同。但是StringBuffer是线程安全的，StringBuffer类中的方法都添加了synchronized关键字，也就是给这个方法添加了一个锁，用来保证线程安全。
最小栈
- 重点总结
  - 1、理解创建栈及其函数的方式（非Stack类）
  - 2、对于栈中最大值，最小值等的查找及存储

比较含退格的字符串

给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。 # 代表退格字符。
注意：如果对空文本输入退格字符，文本继续为空。

示例 1：
输入：S = “ab#c”, T = “ad#c”
输出：true
解释：S 和 T 都会变成 “ac”。
示例 2：
输入：S = “ab##”, T = “c#d#”
输出：true
解释：S 和 T 都会变成 “”。
示例 3：
输入：S = “a##c”, T = “#a#c”
输出：true
解释：S 和 T 都会变成 “c”。
示例 4：
输入：S = “a#c”, T = “b”
输出：false
解释：S 会变成 “c”，但 T 仍然是 “b”。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/backspace-string-compare
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

重点总结

1. 使用堆栈思想解决问题

2. 使用StringBuffer(慢但是线程安全)和StringBuilder(快但是不是线程安全的)

3.遍历字符串的方法。使用charAt()，subString，toCharArray等 https://blog.csdn.net/u014570939/article/details/85482349

class Solution {
    public boolean backspaceCompare(String S, String T) {
        return build(S).equals(build(T));
    }
    public String build(String str) {
        StringBuffer ret = new StringBuffer();
        int length = str.length();
        for (int i = 0; i < length; ++i) {
            char ch = str.charAt(i);
            if (ch != '#') {
                ret.append(ch);
            } else {
                if (ret.length() > 0) {
                    ret.deleteCharAt(ret.length() - 1);
                }
            }
        }
        return ret.toString();
    }
}

整理字符串

给你一个由大小写英文字母组成的字符串 s 。
一个整理好的字符串中，两个相邻字符 s[i] 和 s[i+1]，其中 0<= i <= s.length-2 ，要满足如下条件:
若 s[i] 是小写字符，则 s[i+1] 不可以是相同的大写字符。
若 s[i] 是大写字符，则 s[i+1] 不可以是相同的小写字符。
请你将字符串整理好，每次你都可以从字符串中选出满足上述条件的两个相邻字符并删除，直到字符串整理好为止。
请返回整理好的字符串。题目保证在给出的约束条件下，测试样例对应的答案是唯一的。
注意：空字符串也属于整理好的字符串，尽管其中没有任何字符。

示例 1：
输入：s = “leEeetcode”
输出：”leetcode”
解释：无论你第一次选的是 i = 1 还是 i = 2，都会使 “leEeetcode” 缩减为 “leetcode” 。

示例 2：
输入：s = “abBAcC”
输出：””
解释：存在多种不同情况，但所有的情况都会导致相同的结果。例如：
“abBAcC” —> “aAcC” —> “cC” —> “”
“abBAcC” —> “abBA” —> “aA” —> “”

示例 3：
输入：s = “s”
输出：”s”

提示：
1 <= s.length <= 100
s 只包含小写和大写英文字母

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/make-the-string-great
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

重点总结

1. 使用StringBuffer(慢但是线程安全)和StringBuilder(快但是不是线程安全的)

2.遍历字符串的方法。使用charAt()，subString，toCharArray等 https://blog.csdn.net/u014570939/article/details/85482349

class Solution {
    public String makeGood(String s) {
        StringBuffer ret = new StringBuffer();
        int retIndex = -1;
        int length = s.length();
        for (int i = 0; i < length; i++) {
            char ch = s.charAt(i);
            if (ret.length() > 0 && Character.toLowerCase(ret.charAt(retIndex)) == Character.toLowerCase(ch) && ret.charAt(retIndex) != ch) {
                ret.deleteCharAt(retIndex);
                retIndex--;
            } else {
                ret.append(ch);
                retIndex++;
            }
        }
        return ret.toString();
    }
}

遍历字符串的方法

class LeetCodeTest {
    public static void main(String[] args) {
        String s = "ilovecoding";
        int length = s.length();
//        使用charAt()方法
        System.out.println("This is charAt()");
        for (int i = 0; i < length; i++) {
            char c = s.charAt(i);
            System.out.print(c);
        }
        System.out.println("");

//        使用toCharArray()方法
        System.out.println("This is toCharArray()");
        char[] c = s.toCharArray();
        for(char cc : c){
            System.out.print(cc);
        }
        System.out.println("");

//        使用subString()方法
        System.out.println("This is subString()");
        for (int i = 0; i < length; i++) {
            String ss = s.substring(i,i+1);
            System.out.print(ss);

        }
    }
}

删除最外层的括号

有效括号字符串为空 (“”)、”(“ + A + “)” 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。例如，””，”()”，”(())()” 和 “(()(()))” 都是有效的括号字符串。
如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。
给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + … + P_k，其中 P_i 是有效括号字符串原语。
对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。

示例 1：
输入：”(()())(())”
输出：”()()()”
解释：
输入字符串为 “(()())(())”，原语化分解得到 “(()())” + “(())”，
删除每个部分中的最外层括号后得到 “()()” + “()” = “()()()”。

示例 2：
输入：”(()())(())(()(()))”
输出：”()()()()(())”
解释：
输入字符串为 “(()())(())(()(()))”，原语化分解得到 “(()())” + “(())” + “(()(()))”，
删除每个部分中的最外层括号后得到 “()()” + “()” + “()(())” = “()()()()(())”。

示例 3：
输入：”()()”
输出：””
解释：
输入字符串为 “()()”，原语化分解得到 “()” + “()”，
删除每个部分中的最外层括号后得到 “” + “” = “”。

提示：
S.length <= 10000
S[i] 为 “(“ 或 “)”
S 是一个有效括号字符串

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-outermost-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。、

重点总结

1、理解题意，题目是将括号拆分成A+B+…的形式，然后去掉最外层的括号即可

2、熟练StringBuilder和StringBuffer的用法:StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。StringBuilder与其基本相同。但是StringBuffer是线程安全的，StringBuffer类中的方法都添加了synchronized关键字，也就是给这个方法添加了一个锁，用来保证线程安全。

class Solution {
    public String removeOuterParentheses(String S) {
        //新建一个如我般的StringBuilder
        StringBuilder sb = new StringBuilder();
        //level代表目前的指针所在位置是外层还是内层括号,>1则是内层括号
        int level = 0;
        //开始遍历字符串中的字符
        for (char c : S.toCharArray()) {
            //)说明完成了一个内层括号，可以将level--了
            if (c == ')') --level;
            //level大于1，说明已经进入内层括号了，可以保留了
            if (level >= 1) sb.append(c);
            //如果是(代表
            if (c == '(') ++level;
        }
        return sb.toString();
    }
}

最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。

示例:
输入：
[“MinStack”,”push”,”push”,”push”,”getMin”,”pop”,”top”,”getMin”]
[[],[-2],[0],[-3],[],[],[],[]]
输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); —> 返回 -3.
minStack.pop();
minStack.top(); —> 返回 0.
minStack.getMin(); —> 返回 -2.

提示：
pop、top 和 getMin 操作总是在非空栈上调用。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/min-stack
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

重点总结

1、理解创建栈及其函数的方式（非Stack类）

2、对于栈中最大值，最小值等的查找及存储

class MinStack {
    private NodeList head;

    /** initialize your data structure here. */
    public MinStack() {
    }

    public void push(int x) {
        if(head==null){
            head = new NodeList(x,x,null);
        }else{
            head = new NodeList(x,Math.min(x,head.min),head);
        }
    }

    public void pop() {
        head = head.next;
    }

    public int top() {
        return head.val;
    }

    public int getMin() {
        return head.min;
    }

}

class NodeList{
    int val;
    int min;
    NodeList next;
    public NodeList(int val,int min,NodeList next){
        this.val = val;
        this.min = min;
        this.next = next;
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

栈和队列题目

比较含退格的字符串

重点总结

1. 使用堆栈思想解决问题

2. 使用StringBuffer(慢但是线程安全)和StringBuilder(快但是不是线程安全的)

3.遍历字符串的方法。使用charAt()，subString，toCharArray等 https://blog.csdn.net/u014570939/article/details/85482349

整理字符串

重点总结

1. 使用StringBuffer(慢但是线程安全)和StringBuilder(快但是不是线程安全的)

2.遍历字符串的方法。使用charAt()，subString，toCharArray等 https://blog.csdn.net/u014570939/article/details/85482349

遍历字符串的方法

删除最外层的括号

重点总结

1、理解题意，题目是将括号拆分成A+B+…的形式，然后去掉最外层的括号即可

最小栈

重点总结

1、理解创建栈及其函数的方式（非Stack类）

2、对于栈中最大值，最小值等的查找及存储