剑指Offer行榜【牛客网】练习（十二）

1、构建乘积数组

题目描述：
给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。

思路：
方法1、暴力求解O(n^2)
方法2、求得每一个数左侧和右侧的乘积O(n)

代码：

// method 1
public class Solution {
    public int[] multiply(int[] A) {
        if(A.length<=1){
            return A;
        }else{
            int[] B = new int[A.length];
            for(int i=0;i<B.length;i++){
                B[i] = getResult(A,i);
            }
            return B;
        }
    }
    public int getResult(int[] A,int i){
        int result = 1;
        for(int j=0;j<A.length;j++){
            if(j!=i){
                result = result * A[j];
            }
        }
        return result;
    }
}
// method 2
public class Solution {
    public int[] multiply(int[] A) {
        if(A.length<=1){
            return A;
        }
        int[] left = new int[A.length];
        left[0] = 1;
        for(int i=1;i<left.length;i++){
            left[i] = left[i-1]*A[i-1];
        }
        int[] right = new int[A.length];
        right[right.length-1] = 1;
        for(int i=right.length-2;i>=0;i--){
            right[i] = right[i+1]*A[i+1];
        }
        int[] result = new int[A.length];
        for(int i=0;i<result.length;i++){
            result[i] = left[i]*right[i];
        }
        return result;
    }
}

2、正则表达式匹配

题目描述：
请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配

思路：
递归终止条件：
1、str和pattern都到末尾，匹配成功
2、str没到末尾，pattern到末尾，匹配失败
递归匹配：
1、patternIndex+1位置不是*，或者patternIndex+1已经没有字符

• 如果str已经没有字符，则失败
• 如果str有字符，且匹配（相等或patternIndex处为’.’），则继续匹配下一个字符【strIndex+1，patternIndex+1】
• 如果str有字符，且不匹配，则失败

2、patternIndex+1位置是*

• 如果str已经没有字符，继续匹配【strIndex，patternIndex+2】
• 如果str有字符，且匹配（相等或patternIndex处为’.’），则继续匹配下一个字符【strIndex+1，patternIndex || strIndex，patternIndex+2（跳过这个x*重新匹配）】
• 如果str有字符，且不匹配，继续匹配【strIndex，patternIndex+2】

代码：

public class Solution {
    public boolean match(char[] str, char[] pattern)
    {
        return matchTool(str,0,pattern,0);
    }
    
    public boolean matchTool(char[] str, int strIndex,
                            char[] pattern, int patternIndex){
        if(strIndex>=str.length&&patternIndex>=pattern.length){
            return true;
        }
        if(strIndex<str.length&&patternIndex>=pattern.length){
            return false;
        }
        if(patternIndex+1>=pattern.length||pattern[patternIndex+1]!='*'){
            if(strIndex>=str.length){
                return false;
            }
            if(str[strIndex]==pattern[patternIndex]||pattern[patternIndex]=='.'){
                return matchTool(str,strIndex+1,pattern,patternIndex+1);
            }else{
                return false;
            }
        }else{
            if(strIndex>=str.length){
                return matchTool(str,strIndex,pattern,patternIndex+2);
            }
            if(str[strIndex]==pattern[patternIndex]||pattern[patternIndex]=='.'){
                return matchTool(str,strIndex,pattern,patternIndex+2)
                    || matchTool(str,strIndex+1,pattern,patternIndex);
            }else{
                return matchTool(str,strIndex,pattern,patternIndex+2);
            }
        }
    }
}

3、表示数值的字符串

题目描述：
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。 但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。

思路：
1、处理e之前的部分：处理符号，e之前只能有小数点和数字
2、处理e之后的部分：处理符号，除此之外都是数字且必须有数字

代码：

public class Solution {
    public boolean isNumeric(char[] str) {
        if(str.length==0){
            return false;
        }
        int start = 0;
        if(str[0]=='+'||str[0]=='-')start = 1;
        int index = isNum(str,start);
        if(index==-1){
            return true;
        }else{
            if(str[index]=='.'){
                index = isNum(str,index+1);
            }
            if(index==-1)return true;
            if(str[index]=='e'||str[index]=='E'){
                if(index+1>=str.length){
                    return false;
                }else{
                    int leftIndex = -1;
                    if(str[index+1]=='-'||str[index+1]=='+'){
                        leftIndex = isNum(str,index+2);
                    }else{
                        leftIndex = isNum(str,index+1);
                    }
                    if(leftIndex==-1){
                        return true;
                    }else{
                        return false;
                    }
                }
            }else{
                return false;
            }
        }
    }
    
    public int isNum(char[] str,int start){
        for(int i=start;i<str.length;i++){
            int charnum = str[i]-'0';
            if(charnum>=0&&charnum<=9){
                continue;
            }else{
                return i;
            }
        }
        return -1;
    }
}

4、字符流中第一个不重复的字符

题目描述：
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。

思路：
使用两个ArrayList，其中一个保存原有所有字符，另一个保留只出现一次的字符。当加入的字符重复时，剔除第二个list中的所有该字符。（重复的判断利用了indexOf返回第一个字符出现index的原理，若返回值不等于刚插入的index则重复）

代码：

import java.util.ArrayList;
public class Solution {
    ArrayList<Character> str = new ArrayList<>();
    ArrayList<Character> dup = new ArrayList<>();
    int count = 0;
    //Insert one char from stringstream
    public void Insert(char ch)
    {
        str.add(ch);
        dup.add(ch);
        if(str.indexOf(ch)!=count){
            while(dup.indexOf(ch)>=0){
                dup.remove((Character)ch);
            }
        }
        count++;
    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
        if(dup.size()>0){
            return dup.get(0);
        }else{
            return '#';
        }
    }
}

5、链表中环的入口结点

题目描述：
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

思路：
用ArrayList保存结点的值，如果重复，则表示进入循环，这个结点就是所求入口。

代码：

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
import java.util.ArrayList;
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead)
    {
        ArrayList<Integer> vals = new ArrayList<>();
        while(pHead!=null){
            if(vals.indexOf(pHead.val)>=0){
                return pHead;
            }else{
                vals.add(pHead.val);
            }
            pHead = pHead.next;
        }
        return null;
    }
}