日常打卡JAVA五道题（1.20）

058最后一个单词的长度

解析+代码一

class Solution {
    public int lengthOfLastWord(String s) {
        /*
        题目信息：
        最后一个单词的长度
        单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
        */
        // 首先同trim() 方法用于删除字符串的头尾空白符。
        String str=new String(s.trim());
        // 首先判断字符串是否还存在空格
        if(!str.contains(" ")){
            // 不存在空格
            return str.length();
        }
        else{
            // 存在空格
            // 通过空格来截取字符串创建数组
            // 正则表达式\s表示匹配任何空白字符，+表示匹配一次或多次
            //分割一个或者多个空格
            String[] arr=str.split("\\s+");
            // 返回最后一个字符串的长度
            return arr[arr.length-1].length();
        }
        
    }
}

解析+代码二（耗时较短）

class Solution {
    public int lengthOfLastWord(String s) {
        /*
        题目信息：
        最后一个单词的长度
        单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
        */
        // 首先同trim() 方法用于删除字符串的头尾空白符。
        String str=new String(s.trim());
        // 首先判断字符串是否还存在空格
        if(!str.contains(" ")){
            // 不存在空格
            // 仅一个单词
            return str.length();
        }
        else{
            // 存在空格
            // 多个单词
            // 记录最后一个单词的长度
            int length=1;
            // 逆序遍历
            for(int i=str.length()-2;i>=0;i--){
                // 判断是否遇到空格
                if(str.charAt(i)!=' '){
                    // 没有遇到
                    // 仍在一个单词的范畴
                    length++;
                }
                else{
                    // 遇到空格，结束
                    break;
                }
            }
            return length;
        }
    }
}

066加一

解析+代码

class Solution {
    public int[] plusOne(int[] digits) {
        // 对最后一个元素操作，注意查看是否有进位
        // 首先先检查一下数组长度
        int length=digits.length;
        // 初始化进位
        int so=0;
        // 对最后一位进行处理
        // 判断最后一位是否小于9
        if(digits[length-1]<9){
            digits[length-1]++;
        }
        else{
            digits[length-1]=0;
            so=1;
        }
        // 检查数组长度
        // 长度为1并且无进位
        if(length==1&&so==0){
            return digits;
        }
        // 长度为1并且有进位
        else if(length==1&&so==1){
            return new int []{1,0};
        }
        // 长度大于1并且无进位
        else if(length>1&&so==0){
            return digits;
        }
        // 长度大于1并且有进位
        else{
            // 逆序遍历数组，从倒数第二个开始
            for(int i=length-2;i>=0;i--){
                // 如果某个元素大小小于9
                if(digits[i]<9){
                    digits[i]++;
                    so=0;
                    return digits;
                }
                else{
                    digits[i]=0;
                }
            }
            // 判断是否还有进位
            // 没有进位
            if(so==0){
                return digits;
            }
            // 有进位
            // 产生新的一位数
            else{
                // 创建数组，默认为0
                int[] arr=new int [length+1];
                arr[0]=1;
                return arr;
            }
        }
    }
}

067二进制求和

解析+代码

class Solution {
    public String addBinary(String a, String b) {
        // 判断是否有字符串为0
        // 字符串a为“0”
        if(a.equals("0")){
            return b;
        }
        // 字符串b为“0”
        else if(b.equals("0")){
            return a;
        }
        // 两者均不为“0”
        else{
            // 初始化进位为0;
            int so=0;
            // 求取两个字符的长度
            int length1=a.length();
            int length2=b.length();
            // 存储最后的二进制
            StringBuffer str=new StringBuffer();
            // 遍历字符串
            for(int i=length1-1,j=length2-1;i>=0||j>=0;i--,j--){
                // 两个字符串都未遍历完
                if(i>=0&&j>=0){
                    // 获取当前遍历的下标对应的字符
                    char ch1=a.charAt(i);
                    char ch2=b.charAt(j);
                    // 求对应的整数
                    int num1=ch1-'0';
                    int num2=ch2-'0';
                    int nums=num1+num2+so;
                    // 本位
                    int co=nums%2;
                    str.append(new String(String.valueOf(co)));
                    // 进位
                    so=nums/2;
                }
                // 仅第一个未遍历完
                else if(i>=0){
                     // 获取当前遍历的下标对应的字符
                    char ch1=a.charAt(i);
                    // 求对应的整数
                    int num1=ch1-'0';
                    int nums=num1+so;
                    // 本位
                    int co=nums%2;
                    str.append(new String(String.valueOf(co)));
                    // 进位
                    so=nums/2;
                }
                // 仅第二个字符串未遍历完
                else{
                     // 获取当前遍历的下标对应的字符
                    char ch2=b.charAt(j);
                    // 整数
                    int num2=ch2-'0';
                    int nums=num2+so;
                    // 本位
                    int co=nums%2;
                    str.append(new String(String.valueOf(co)));
                    // 进位
                    so=nums/2;
                }
            }
            // 判断是否存在进位，产生新的数
            if(so==0){
                // 不存在
                return str.reverse().toString();
            }
            else{
                return str.append("1").reverse().toString();
            }
        }
    }
}

069Sqrt(x)

解析+代码

class Solution {
    public int mySqrt(int x) {
        // 容易犯错地方之一：忘记考虑零
        if(x==0){
            return 0;
        }
        else{
            int i=1;
            // 容易犯错地方二：忘记等号
            while(x/i>=i){
                i++;
            }
            return --i;
        }
    }
}

070爬楼梯

解析+代码

class Solution {
    public int climbStairs(int n) {
        // 动态规划 求
        //台阶数错误
        if(n<0){
            return -1;
        }
        else if(n<=2){
            return n;
        }
        else{
            // 创建数组，记录每个台阶对应的方法
            int[] dp=new int [n+1];
            // 容易犯错地方：初始化条件从1，2开始
            // 若从0，1开始，则会dp[2]=dp[1]+dp[0]=1错误
            dp[1]=1;
            dp[2]=2;
            // 从三遍历到n
            for(int i=3;i<=n;i++){
                /*
                 到达第n个台阶的方法为到达第n-1个台阶的方法
                和到达第n-2个台阶的方法之和
                */
                dp[i]=dp[i-1]+dp[i-2];
            }
            return dp[n];
        }
    }
}