力扣刷题day01

两数之和

        在一个数组中找到两个元素，使得他们的和为传入的target，返回他们的下标，元素只可用一次。

1、暴力解法

        双层for循环遍历数组，使得每两个元素都相加一次进行比较。

class Solution {
    public int[] twoSum(int[] nums, int target) {
         int [] a = new int [2];
         for(int i = 0;i < nums.length - 1;i++){
             for(int j = i+1;j < nums.length;j++){
                if(nums[i] + nums[j] == target){
                    a[0] = i;
                    a[1] = j;
                }
             }
         }
         

          return a;
    }
}

2、使用hashmap

        使用hashmap结构，元素作为key，下标作为value，把数组的第一个元素和下标放入哈希表中，从第二个元素开始循环比较。倘若target和循环的元素的差值在哈希表中存在，那么就返回该元素的下标和哈希表中的以差值作为key的value值。倘若不存在，则把该元素和下标放入哈希表中。

class Solution {
    public int[] twoSum(int[] nums, int target) {
       int length = nums.length;
         for(int i = 0; i < length; i++){
             for(int j =i+1; j<length; j++){
                 if(nums[i] + nums[j] == target){
                     return new int[]{i,j};
                 }
             }
         }   
         return new int[0];
    }
}

回文数

        回文数是指一个整型正向遍历和反向遍历元素一致。

解法：负数显然不是回文数，所以先进行正负值的判断。然后把该整数转为String类型，再使用使用StringBuffer 的reverse()方法进行反转，反转后的字符串和反转前进行比较。

class Solution {
    public boolean isPalindrome(int x) {
        if(x < 0) return false;
        StringBuffer sb = new StringBuffer(String.valueOf(x));
        return sb.reverse().toString().equals(String.valueOf(x));
    }
}

罗马数字转整数

        把罗马数字转为对应的十进制整数

解法：一串罗马数字可以把它进行拆分，最后的整数值就是拆分后每个字符对应的数值相加。通常数值较大的在左边，数值较小的在右边。但是有一种特殊情况，例如IV表示4。数字较小的I在左边，这个时候的结果就是V-I的值。

        所以我们把各个罗马字符对应的数字存放到哈希表中，对整个罗马数字字符进行遍历，如果左边比右边的数值小就进行减法，左边的数值更大就进行加法，最后返回结果。

class Solution {
     public int romanToInt(String s) {
        int length = s.length();
        int result = 0;
        Map<Character, Integer> map = new HashMap<>();
        map.put('I',1);
        map.put('V',5);
        map.put('X',10);
        map.put('L',50);
        map.put('C',100);
        map.put('D',500);
        map.put('M',1000);

        for (int i = 0;i < length;i++){
            if(i<length-1 && map.get(s.charAt(i)) < map.get(s.charAt(i+1))){
                result -= map.get(s.charAt(i));
            }else {
                result += map.get(s.charAt(i));
            }
        }
        return result;
    }
}

最长公共前缀

        找出字符串数组中每个元素共有的最长前缀。

解法：我们可以先定义一个方法substring()两两进行比较，找出两个字符串共有的前缀。公共前缀肯定比两个元素的长度都短，所以我们找出较短的长度，以此为条件比较两个字符串中的单个字符是否相等，最后使用substring()截取相应的公共前缀。然后我们遍历整个字符串数组，把第一个元素当做共有前缀，定义一个变量prefix接收，调用上面定义的方法和下一个元素进行寻找公共前缀，最后赋值给prefix变量，这样当整个数组都遍历完后，得出的就是最长公共前缀。

class Solution {
    public String longestCommonPrefix(String[] strs) {
            if (strs == null || strs.length == 0){
            return  "";
        }
        String prefix = strs[0];
        int length = strs.length;
        for (int i = 1; i<length;i++){
            prefix = subString(prefix,strs[i]);
            if (prefix.length() == 0){
                break;
            }
        }
        return prefix;
    }

    //截取两个字符串的最长子串
    public String subString(String str1,String str2){
        int length = Math.min(str1.length(),str2.length());
        int index = 0;
        while (index < length && str1.charAt(index) == str2.charAt(index)){
            index++;
        }
        return str1.substring(0,index);
    }
}