LeetCode-20,155，面试题02.07

LeetCode20:

题目描述：

解题思路：
先将字符串变为char[]，遍历整个char[]。如果当前字符是左括号（ { [，将此字符入栈，如果不是左括号，先判断栈是否为空，如果栈是空的，说明没有左括号，以右括号开头，则返回false。如果当前的字符和栈中的左括号匹配，则将栈顶出栈。最后需要判断栈是否为空，如果不为空则代表还存在未被匹配的左括号，则返回false。

代码：

class Solution {
    public boolean isValid(String s) {
    Stack<Character> stack=new Stack<>();
        char[]  chars=s.toCharArray();

        for(int i=0;i<chars.length;i++){
            if(chars[i]=='(' || chars[i]=='[' ||chars[i]=='{' ){
                stack.push(chars[i]);
            }else{
                if(stack.isEmpty()){
                    return false;
                }

                char top=stack.peek();

                if(chars[i]==')' && top=='(' ||  chars[i]=='}' && top=='{'   ||   chars[i]==']' && top=='['){
                    stack.pop();
                }else{
                    return false;
                }

            }
        }

        if(!stack.isEmpty()){
            return false;
        }


        return true;
    }
}

LeetCode155：

题目描述：
解题思路：
最小栈MinStack类，设计两个Stack，一个就是普通栈stack，另一个是min栈，表示当前栈顶元素为stack中最小的元素。

1. push：对于stack来说，所有的元素都需要被push进去。当min为空，直接push，如果民不为空，则需要判断min当前栈顶元素和当前需要被push的元素比大小。
2. pop：对于stack来说，直接pop，而对于min来说，需要判断当前出栈的元素和min栈顶元素是否相等，相等还需要让min进行pop操作。
3. top：对stack进行peek操作。
4. getMin：对min进行peek操作。
   代码：

class MinStack {

   
    private Stack<Integer> stack;
    private Stack<Integer> min;

    public MinStack() {
    this.stack=new Stack<>();
    this.min=new Stack<>();
    }
    
    public void push(int val) {
        stack.push(val);
        if(min.empty()){
            min.push(val);
        }else {
            int x=min.peek();
            if(val<=x){
                min.push(val);
            }
        }
    }
    
    public void pop() {
        if(stack.empty()){
            return;
        }
        int pop=stack.pop();
        if(pop==min.peek()){
            min.pop();
        }
    }
    
    public int top() {
        if(stack.empty()){
            return -1;
        }
      return stack.peek();
    }
    
    public int getMin() {
        if(min.empty()){
            return -1;
        }
        return min.peek();
    }
}

面试题02.07：

题目描述：

解题思路：
两个单链表的长度不一定相同，需要先知道链表分别的长度。找两个标识，初始都在两链表的头节点。比较两个链表长度，较长的链表的标识先走两链表的差值的长度。接着就让连个链表的标识一步一步向后走，如果在某一位置相同则返回这个位置的节点，如果最后某个链表为空还没有找到相交点则返回null。

代码：

ublic class Solution {


public static  int getSize(ListNode head){

    if(head==null){
        return 0;
    }

    int count =0;

    while(head !=null){
        head=head.next;
        count++;
    }
        return count;
}

    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

        if(headB ==null || headA==null){
            return null;
        }

       int sizeA= getSize(headA);
       int sizeB=getSize(headB);

       ListNode tempA=headA;
        ListNode tempB=headB;

        if(sizeA>sizeB){
            for(int i=0;i<(sizeA-sizeB);i++){
                tempA=tempA.next;
            }
        }else{
               for(int i=0;i<(sizeB-sizeA);i++){
                tempB=tempB.next;
            }
        }

        while(tempA!=tempB){
            if(tempA==null || tempB==null){
                return null;
            }
            tempA=tempA.next;
            tempB=tempB.next;
        }

        return tempA;

    }
}