JAVA日常练习

字符串练习

第一题。

（大数加法）描述
以字符串的形式读入两个数字，编写一个函数计算它们的和，以字符串形式返回。例如输入"1",“99”，返回"100"。

对于这道题。
我们数学思维是从个位开始相加，如果超10就进1，于是我们可以利用库函数先拿到最后一个字符。s.length()-1;然后s.CharAt(s.length()-1)拿到最后一个子串，然后定义一个进位代表。如下图，当不满足
i>=0 || j >=0,跳出循环，利用三目表达式获取每一位的数字。最后如果carry
！=0说明还有一个为没进。最后还需要逆置一下字符串，因为从个位开始拼接的。

   public String solve (String s, String t) {
        // write code here
        StringBuilder sb = new StringBuilder();
        int i = s.length()-1;
        int j = t.length()-1;
        int carry = 0;                      //进位代表
        while(i >= 0 || j >= 0) {
            int s1 = (i >= 0 ? s.charAt(i) -'0':0);
            int t2 = (j >= 0 ? t.charAt(j) -'0':0);
            int sum = s1 + t2 + carry;
            carry = sum / 10; //进位要加的，加入到下次计算
            sum = sum % 10;   
            sb.append(sum);
            i--;
            j--;
        }
        if(carry != 0) {
            sb.append(carry);
        }
        return sb.reverse().toString();
    }

第二题

（字符串变形）描述
对于一个长度为 n 字符串，我们需要对它做一些变形。
首先这个字符串中包含着一些空格，就像"Hello World"一样，然后我们要做的是把这个字符串中由空格隔开的单词反序，同时反转每个字符的大小写。
比如"Hello World"变形后就变成了"wORLD hELLO"。

主要思路，主要利用StringBuilder拼接。先以空格分割，然后从后往前拿，每一个单词再用s.CharAt()拿到每一个字母，利用Ascll判断大小写，进而转换，当一个字母弄完，然后拼接一个空格。当全部弄完需要转为字符串，然后分割掉字符串最后一个下标，因为会多拼接一个空格，代码如下

    public String trans(String s, int n) {
        // write code here
        String[] ss = s.split(" ",-1);
        StringBuilder ret = new StringBuilder();
        for(int i = ss.length-1;i >= 0;i--) {
            String str = ss[i];
            for(int j = 0;j < str.length();j++) {
                char c = str.charAt(j);
                if(c >= 'a' && c <= 'z') {           //如果是小写
                    ret.append((char) (c + 'A'-'a'));      //转大写
                } else {
                    ret.append((char)(c +'a'-'A'));
                }
            }
            ret.append(" ");          //是StringBuilder最后需要转为String
        }
        return ret.toString().substring(0,ret.length()-1);       //把最后一个空格切除了
    }

第三题

（最长公共前缀）描述
给你一个大小为 n 的字符串数组 strs ，其中包含n个字符串 , 编写一个函数来查找字符串数组中的最长公共前缀，返回这个公共前缀。

因为是最长公共前缀，所以我们可以拿出第一个字符串，然后拿出这个字符串子串的每一个，遍历后面的字符串进行比较，如果不相等就结束找到了。代码如下

    public String longestCommonPrefix (String[] strs) {
        // write code here
        if(strs == null || strs.length == 0) {
            return "";
        } 
        int onelength = strs[0].length();
        for(int i = 0;i < onelength;i++) {
            char tmp = strs[0].charAt(i);
            //遍历剩余的字符串
            for(int j = 1;j < strs.length;j++) {
                if(i == strs[j].length() || tmp != strs[j].charAt(i)) {
                    /**
                    如果i等于剩余子字符串长度，说明找到最短的，则结束；
                    如果tmp不等于子字符串的字符，也跳出
                     */
                    return strs[0].substring(0,i);
                }
            }
        }
        return strs[0];
    }

链表

（链表内指定区间反转）描述

代码如下

    public ListNode reverseBetween (ListNode head, int m, int n) {
        // write code here
        if(head == null) {
            return null;
        }
        ListNode newhead = new ListNode(-1);  //定义前驱一个节点
        newhead.next = head;
        ListNode pre = newhead;
        ListNode cur = head;
        int i = m;
        while(i-1 != 0) {  
            pre = pre.next;   //开始交换节点的前一个
            cur = cur.next;   //找到开始交换的节点
            i--;
        }
        int ret = n-m;    //交换次数
        while(ret != 0) {
            ListNode curNext = cur.next;  //保存下一个节点
            cur.next = curNext.next;       
            curNext.next = pre.next;
            pre.next = curNext;
            ret--;
        }
        return newhead.next;
    }