日常打卡JAVA五道题（1.18）

009回文数

解析+代码

class Solution {
    public boolean isPalindrome(int x) {
        // 回文数，可以利用StringBuffer的reverse反转函数
        // 将n转换为StringBuffer类型
        StringBuffer s=new StringBuffer(String.valueOf(x));
        return s.reverse().toString().equals(String.valueOf(x));
        /*
        reverse方法实现字符串反转，StringBuffer有但是String没有
        String.valuOf方法实现转换为字符串类型功能
        toString将调用对象转换为字符串String类型
        equals用来比较两字符串是否相等
        */
    }
}

013罗马数字转整数

解析+代码

class Solution {
    public int romanToInt(String s) {
        /*
        题目重点：
        通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例
        */
        /*
        思路：
        通过变量num来记录整数
        逆序遍历字符串
        注意判断当前遍历的罗马数字是否比邻近的右边的罗马数字小
        如果比右边的小，则减
        否则加
        */
        // 记录整数
        int num=0;
        // 记录s的长度
        int length=s.length();
        // 求最后一个字符的罗马数字
        char rear=s.charAt(length-1);
        // 求最后一个字符的罗马数字对应的整数
        switch(rear){
                case 'I':
                    num=1;
                    break;
                case 'V':
                    num=5;
                    break;
                case 'X':
                    num=10;
                    break;
                case 'L':
                    num=50;
                    break; 
                case 'C':
                    num=100;
                    break;
                case 'D':
                    num=500;
                    break;
                case 'M':
                    num=1000;
                    break; 
        }
        // 字符串长度为1
        if(s.length()==1){
            return num;
        }
        // 字符串长度大于1
        else{
            // 记录当前遍历的罗马数字右边邻近的罗马数字对应的数字
            int index1=num;
            for(int i=length-2;i>=0;i--){
                // 记录当前遍历的罗马数字
                char front=s.charAt(i);
                // 记录当前罗马数字对应得数字
                int index2=0;
                // 求罗马数字对应的数字
                switch(front){
                case 'I':
                    index2=1;
                    break;
                case 'V':
                    index2=5;
                    break;
                case 'X':
                    index2=10;
                    break;
                case 'L':
                    index2=50;
                    break; 
                case 'C':
                    index2=100;
                    break;
                case 'D':
                    index2=500;
                    break;
                case 'M':
                    index2=1000;
                    break; 
                 }
                //  当前遍历的罗马数字小于右边邻近的数字时
                 if(index2<index1){
                    //  做减法
                     num-=index2;
                 }
                //  反之
                 else{
                    //  做加法
                     num+=index2;
                 }
                //  记录当前的罗马数字对应的数字
                 index1=index2;
            }
        }
        return num;
    }
}

014最长公共前缀

解析+代码

class Solution {
    public String longestCommonPrefix(String[] strs) {
        /*
        两个for循环
        第一个for循环：
        结束条件：第一个字符串中的长度或第二个for循环中遍历的字符不相等
        第二个for循环：
        结束条件：字符数组的长度或者遍历的字符不相等
        */
        int i=0,j=0;
        // 第一个for循环：
        // 遍历第一个字符串的字符
        for( ;i<strs[0].length();i++){
            // 记录当前遍历的字符
            char s=strs[0].charAt(i);
            // 第二个for循环：
            // 比较与第一个字符串相同下标的字符字符是否相同
            for(j=1;j<strs.length;j++){
                // 注意：容易犯错
                // 防止越界：因为不确定哪个字符串的长度最小
                if(i<strs[j].length()){
                    // 记录当前字符串的下标的字符
                    char ch=strs[j].charAt(i);
                    // 判断字符是否相同
                    if(ch!=s){
                        // 不相同结束
                        break;
                    }  
                }
                // 越界了
                else{
                    break;
                }
            }
            // 判断是否是两字符不相同结束
            if(j<strs.length){
                break;
            }
        }
        // 判断是否存在相同的前缀
        if(i>0){
            // 存在
            return strs[0].substring(0,i);
        }else{
            // 不存在
            return "";
        }
    }
}

020有效的括号

解析+代码

class Solution {
    public boolean isValid(String s) {
        //    考察知识点：栈
        // 先判断字符串的长度，奇数一定不是有效的
        // 记录字符串的长度
        int length=s.length();
        // 判断是否为奇数
        if(length%2!=0){
            // 奇数
            return false;
        }
        else{
            // 偶数
            // 创建栈
            // 注意要用包装类Character
            Stack<Character>stack=new Stack<Character>();
            // 遍历字符串
            for(int i=0;i<length;i++){
                // 记录当前遍历的字符串
                char ch=s.charAt(i);
                // 如果是(、{、[则入栈
                if(ch=='('||ch=='{'||ch=='['){
                    // 入栈push()
                    stack.push(ch);
                }
                // 如果不是,则要取栈顶字符判断
                else{
                    /*
                        易忘记考虑情况一:
                        }[]
                    */
                    // 如果为空栈
                    if(stack.size()==0){
                        return false;
                    }
                    // 不是空栈,判断字符是否相同
                    else if(stack.size()!=0){
                        // 取栈顶字符pop()
                        char t=stack.pop();
                        // 判断是否是[],{},()对应
                        if(t=='('&&ch!=')'||t=='['&&ch!=']'||t=='{'&&ch!='}'){
                            // 不是
                            return false;
                        }
                        else{
                            // 是则继续遍历
                            continue;
                        }
                    }
                }
            }
            /*
            易忘记考虑情况地方二:
            ")}"
            */
            // 判断是否为空栈
            if(stack.size()!=0){
                // 不是空栈
                return false;
            }else{
                // 是空栈
                return true;
            }
        }
        
    }
}

021合并两个有序链表

解析+代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        // 链表list1为空
        if(list1==null&&list2!=null){
            return list2;
        }
        // 链表list2为空
        else if(list1!=null&&list2==null){
            return list1;
        }
        // 两个链表都为空
        else if(list1==null&&list2==null){
            return null;
        }
        // 两个链表都不为空
        else{
            // 创建头结点
            ListNode head=new ListNode();
            ListNode node=head;
            // 遍历链表list1,list2
            while(list1!=null&&list2!=null){
                // 当前遍历list1的结点的val较小或者两者相等
                if(list1.val<=list2.val){
                    node.next=list1;
                    list1=list1.next;
                    node=node.next;
                }
                else{
                    node.next=list2;
                    list2=list2.next;
                    node=node.next;
                }
            }
            // 当list1未遍历完
            if(list1!=null){
                node.next=list1;
            }
            // 当list2未遍历完
            else if(list2!=null){
                node.next=list2;
            }
            return head.next;
        }

    }
}