leetcode刷题之(逆波兰表达式和链表相交)

题目一：逆波兰表达式
这另个题目在之前牛客网上也有见到过。
逆波兰表达式：又称为后缀表达式，新建一个表达式,如果当前字符为变量或者为数字，则压栈，如果是运算符，则将栈顶两个元素弹出作相应运算，结果再入栈，最后当表达式扫描完后，栈里的元素就是计算结果。
leetcode题目对于是一种简化，只考虑了+，-、*、/ 四则运算，对于优先级等运算没有进行描述。
题目链接

题目分析： 对于逆波兰表达式计算使用一个辅助空间栈进行运算，将所有的数值元素压入栈中，对于符号或操作的元素将栈顶另个元素出栈后，进行相应的运算载压入栈中，所有元素计算完成后，栈中的元素即为表达式的结果。

代码如下:

import java.util.Stack;
class Solution {
    public int evalRPN(String[] tokens) {
    //如果当前的表达式是一个偶数，那么不能构成一个算术运算，直接返回。
        if(tokens.length%2==0)return 0;
        Stack<Integer> stack = new Stack<>(); 
        //依次遍历所有的元素
        for(int i=0;i<tokens.length;i++){
        //当前的元素为+时，将栈中的两个元素弹出并进行+操作
            if(tokens[i].equals("+")){
                if(stack.size()<2){
                    return 0;
                }
                stack.push((stack.pop()+stack.pop()));
            }else if(tokens[i].equals("-")){
             //当前的元素为-时，将栈中的两个元素弹出并进行-操作
                 if(stack.size()<2){
                    return 0;
                }
                Integer a = stack.pop();
                Integer b = stack.pop();
                stack.push(b-a);
            }else if(tokens[i].equals("*")){
                 if(stack.size()<2){
                    return 0;
                }
                stack.push((stack.pop() * stack.pop()));
            }else if(tokens[i].equals("/")){
                 if(stack.size()<2){
                    return 0;
                }
                 Integer a = stack.pop();
                Integer b = stack.pop();
                stack.push((b/a));
            }else{
             //当前的元素为数值类型，直接压入栈中
                stack.push(Integer.valueOf(tokens[i]));
            }
        }
        return stack.pop();
    }
}

题目二：链表相交
链表相交是两个单链表是否有公共的结点，指定两个链表返回结果为两条链表相交的第一个节点。
题目链接

题目分析：
链表问题一般会用到链表指针，两条链表由于结点元素个数的不同，两条链表的长度是不同的，对于长链表指针应该先向后移动一定的位置，然后短指针一起向后移动知道找到第一个相交的结点。
代码如下：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    //只要有一条链表为null就不存在交点
      if(headA == null||headB==null)return null;
      ListNode lA = headA;
      ListNode lB = headB;
      int lenA = 0;
      int lenB = 0;
      //计算链表A的长度
      while(lA!=null){
        lenA++;
        lA=lA.next;         
      }  
      //计算链表B的长度
      while(lB!=null){
        lenB++;
        lB=lB.next;  
      }
      //指针回到起点
       lA = headA;
        lB = headB;
        //长链表先走
     if(lenA>lenB){
         int len = lenA - lenB;
        for(int i = 1;i<=len;i++){
            lA=lA.next;
        }
     }else{
        int len = lenB - lenA;
        for(int i = 1;i<=len;i++){
            lB=lB.next;
        }
     }
     //两个指针一起向后移动
     while(lA!=null&&lB!=null){
        if(lA==lB)return lA;
        lA = lA.next;
        lB = lB.next;
     }
     return null;
    }
}

同样一种思想，有的人就是能够将程序写的优雅：
大神代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
      if(headA == null||headB==null)return null;
      ListNode lA = headA;
      ListNode lB = headB;
      while(lA!=null||lB!=null){
          if(lA==lB)return lA;
          lA = lA==null?headB:lA.next;
          lB = lB==null?headA:lB.next;
      }
      return null;
    }
}

注：本人的部分博客放在自己的博客上，由于有的文章需要反复地进行修改与持续学习，相互监督一起进步。
个人博客链接