剑指offer-每日6题之第九天(java版)

最新推荐文章于 2024-10-21 12:54:00 发布

原创最新推荐文章于 2024-10-21 12:54:00 发布 · 348 阅读

1 ·

CC 4.0 BY-SA版权

剑指offer 专栏收录该内容

9 篇文章

订阅专栏

本文解析了六道常见的编程面试题目，包括字符串转整数、查找数组中重复的数字、构建乘积数组、正则表达式匹配、判断字符串是否表示数值以及字符流中第一个不重复的字符。通过详细解释和代码示例，帮助读者理解并掌握这些题目的解题思路。

原题链接：

第一题：把字符串转换成整数
第二题：数组中重复的数字
第三题：构建乘积数组
第四题：正则表达式匹配
第五题：表示数值的字符串
第六题：字符流中第一个不重复的字符

第一题：把字符串转换成整数

题目描述
将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。
数值为0或者字符串不是一个合法的数值则返回0。输入描述: 输入一个字符串,包括数字字母符号,可以为空输出描述:
如果是合法的数值表达则返回该数字，否则返回0

解析

将字符串转换成字符数组,逐个比较,判断是否是数字
若是,则更新sum=sum*10+a[i]-'0'(代码中用了移位,计算比较快)
注意:可能数字字符串有'+','-'所以用一个布尔值标志:负为false

public int StrToInt(String str) {
        if (str.equals("") || str.length() == 0)
            return 0;
        char[] a = str.toCharArray();
        boolean temp = true;
        if (a[0] == '-')
            temp = false;
        int sum = 0;
        for (int i = (a[0] ==  '-' || a[0] == '+') ? 1 : 0; i < a.length; i++){
            if (a[i] < 48 || a[i] > 57)
                return 0;
            sum = (sum<<1)+(sum<<3) + (a[i] & 0xf);//sum*10=sum*(2^1+2^3)
        }
        return temp ? sum : sum * -1;
    }

第二题：数组中重复的数字

题目描述

在一个长度为n的数组里的所有数字都在0到n-1的范围内。
数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。
例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。

解析

方法一：
定义一个布尔型数组，数组的key为第i个位置的元素，value代表这个元素是否访问过，初始化为false(都是未访问的)

public boolean duplicate(int numbers[],int length,int [] duplication) {
        boolean[] k = new boolean[length];        
        for (int i = 0; i < k.length; i++) {
            if (k[numbers[i]] == true) {                
                duplication[0] = numbers[i];                
                return true;           
                 }            
            k[numbers[i]] = true;        
        }        
        return false;
    }

方法二：
调整数组的位置，使得第i个位置存放值为i的元素。
遍历数组，判断当前位的值和下标是否相等：

若相等，则遍历下一位
若不等，则将当前位置i上的元素和numbers[i]位置上的元素比较：若它们相等，则成功！若不等，则将它们两交换
若当前位置i的值也为i，将i向后移一位，重复步骤1，否则，重复步骤2（换完之后numbers[i]位置上的值和它的下标是对应的，但i位置上的元素和下标并不一定对应）

public boolean duplicate(int numbers[],int length,int [] duplication) {
       if(numbers == null || length <= 0) {           
           return false;        }                 
       for(int i = 0; i < length; i++) {            
           while(numbers[i] != i) {                
               if(numbers[i] == numbers[numbers[i]]) {                    
                   duplication[0] = numbers[i];                    
                   return true;                
               }                
               int temp = numbers[i];                
               numbers[i] = numbers[temp];                
               numbers[temp] = temp;            
           }        
       }                 
       return false;
   }

第三题：构建乘积数组

题目描述

给定一个数组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]。不能使用除法。

解析

剑指的思路：
如图：B[i]的值是矩阵中每行的乘积。

求B[i]可以先求B[i]的一部分（下三角,从上往下计算）：
初始化B[i]=1
B[i]=B[i-1]*A[i-1]
然后求B[i]的另一部分（上三角，从下往上计算）:
定义一个变量temp累计上三角的值
初始化temp=1
temp=temp*A[i+1]
然后将这部分值乘到B[i]中，即B[i]=B[i]*temp

public int[] multiply(int[] A) {
       int length = A.length;
       int[] B = new int[length];
       if(length != 0 ){
           B[0] = 1;
           //计算下三角连乘
           for(int i = 1; i < length; i++){
               B[i] = B[i-1] * A[i-1];
           }
           int temp = 1;
           //计算上三角
           for(int j = length-2; j >= 0; j--){
               temp *= A[j+1];
               B[j] *= temp;
           }
       }
       return B;
   }

第四题：正则表达式匹配

题目描述

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

解析

分两种情况：

当模式中第2个字符是'*'
1.1 字符串第1个跟模式第1个不匹配：将模式串后移2位
1.2 字符串第1个跟模式第1个匹配
1.2.1 将模式后移2位
1.2.2 字符串后移1位，模式串后移2位
1.2.3 字符串后移1位，模式串不变
当模式中第2个字符不是'*'
2.1 字符串第1个跟模式第1个匹配：两串都向后移1位，匹配子串
2.2 直接返回false

public class Solution {
    public boolean match(char[] str, char[] pattern){
        if(str==null||pattern==null)
            return false;
        int strindex=0;
        int patindex=0;
        return matchCore(str,strindex,pattern,patindex);
    }
    public boolean matchCore(char[] str,int strindex, char[] pattern,int patindex){
       if(strindex==str.length && patindex==pattern.length)
           return true;
       else if(strindex!=str.length && patindex==pattern.length)
           return false;
        //模式第2个是*，且字符串第1个跟模式第1个匹配,分3种匹配模式；如不匹配，模式后移2位
        if(patindex+1<pattern.length && pattern[patindex+1]=='*'){
            if((strindex != str.length &&pattern[patindex]=='.')||(strindex != str.length && pattern[patindex] == str[strindex]))
                return matchCore(str,strindex+1,pattern,patindex+2)//匹配一次
                    || matchCore(str,strindex+1,pattern,patindex)//匹配多次
                    || matchCore(str,strindex,pattern,patindex+2);//x*被忽略
            else
                
                return matchCore(str,strindex,pattern,patindex+2);//如 aa b*aa
        }
        //模式第2个不是*，且字符串第1个跟模式第1个匹配，则都后移1位，匹配余下的,否则直接返回false
        if((strindex != str.length &&pattern[patindex]=='.')||(strindex != str.length && pattern[patindex] == str[strindex])){
             return matchCore(str,strindex+1,pattern,patindex+1);
        }
        return false;
            
    }
}

第五题：表示数值的字符串

题目描述

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

解析

表示数值的字符串遵循的模式：A[.[B]][e|EC]或者.B[e|EC]（A可以没有，如.123为0.123）
A->整数部分（以'+'或'-'开头的0-9的字符串）
B->小数部分（0-9的字符串）
C->指数部分（以'+'或'-'开头的0-9的字符串）

public class Solution {
   private  int index=0;
   public boolean isNumeric(char[] str) {
       if(str==null || str.length==0)
           return false;
       boolean flag=scanInteger(str);
       if(index<str.length&&str[index]=='.'){
           index++;
           //前后有一个位置有数字就可以 eg:0.123 23.0  23.4
           //为了防止短路,必须将函数调用写到前面
           flag=scanUnsignedInteger(str)||flag;
       }
       if(index<str.length&&(str[index]=='e'||str[index]=='E')){
           index++;
           flag=flag && scanInteger(str);//前后都要有数字 14E18
       }
       return flag && index==str.length;
   }
   public  boolean scanUnsignedInteger(char[] str){
       int before=index;
       while(index<str.length && str[index]>='0'&& str[index]<='9')
           index++;
       return index>before;
   }
   public  boolean scanInteger(char[] str){
       if(index<str.length &&(str[index]=='+'||str[index]=='-'))
           index++;
       return scanUnsignedInteger(str);
   }
}

第六题：字符流中第一个不重复的字符

题目描述

请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
输出描述:
如果当前字符流没有存在出现一次的字符，返回#字符。

解析

字符只能一个接着一个从字符流中读出来。所以可以定义一个容器保存字符在字符流中的位置。选用哈希表，将字符的ASCⅡ码作为key,value为字符在字符流中的位置。
初始化哈希表中每个value为-1（设置一个小于0的数代表没有在字符流中遇到过这个字符），当一个字符第一次从字符流读出来时，将value更新为字符流中的位置。当不是第一次从字符流读出来时（value>0,即已经更新为字符流的下标了)，将value更新为一个特殊值-2（设置一个小于0的且不等于-1的数作为标识都可以）
此时，寻找第一个不重复的字符，即遍历哈希表，找到value>=0且value最小的key

public class Solution {
    public int occurrence[]=new int[256];
    public int index;
    public Solution(){
        for(int i=0;i<256;++i){
            occurrence[i]=-1;
        }
        index=0;
    }
    //Insert one char from stringstream
    public void Insert(char ch)
    {
        if(occurrence[ch]==-1)
            occurrence[ch]=index;
        else if(occurrence[ch]>=0)
            occurrence[ch]=-2;
        index++;
    }
  //return the first appearence once char in current stringstream
    public char FirstAppearingOnce()
    {
       char ch='#';
        int minIndex=Integer.MAX_VALUE;
        for(int i=0;i<256;++i){
            
            if(occurrence[i]>=0&&occurrence[i]<minIndex){
                ch=(char)i;
                minIndex=occurrence[i];
               
            }
        }
        return ch;
    }
}