初级算法（四）

初级算法（四）

1、引言

1、整数反转：给定一个32为的有符号整数，将x中的数字部分反转。输入:123,输出：321
2、字符串中的第一个唯一字符：找到字符串中第一个不重复的索引，不存在返回-1
3、字母异位词：两个字符串中的字符出现次数相同被称为字母异位词

2、整数反转

​ 一开始，想的是先把数字转换为String，然后通过转换为数组，再倒序存放新的字符串中，然后再转换为整数。但是这种解决办法显然不可能，力扣的测试用例通不过。给的整数转换后的数有可能超过范围。因此只能在原来的基础上改变。

	//执行用时：1ms,内存消耗：39.1MB
    public int reverse(int x) {
        if(x==0)
            return 0;
        long res=0;
        while(x!=0){
            res=res*10+x%10;
            x/=10;
        }
        //long型数据转换位int，如果溢出就转换为0，没有就返回转换后的值
        return (int)res == res ? (int) res : 0;
    }

3、字符串中的唯一字符

​ 这题方法一：可以使用一个k值存储状态，并不需要特别的数据结构和算法思想。正常暴力循环就可以解决。

 	//方法一
    //使用一个k值存储不同的状态,不需要特别的数据结构和算法思想
    // 其中字符串转数组，也可以选择不转
    //执行用时：14ms,内存消耗：41.8MB
    //本质是：暴力算法
    public int firstUniqChar(String s) {
        if(s.length()==1)
            return 0;
        int k=0;
        char[] chars = s.toCharArray();
        for (int i = 0; i <chars.length ; i++) {
            for (int j = 0; j <chars.length ; j++) {
               if(i==j)
                   continue;
               if(chars[i]!=chars[j]){
                   k=1;
               }
               if(chars[i]==chars[j]){
                   k=0;
                   break;
               }
            }
            if(k!=0){
                return i;
            }
        }
        return -1;
    }

​ 方法二: 就是完全不需要任何思想，主要是利用Java自带的api库。

	//方法二
    //使用Java自带的api
    //indexOf是返回s字符串中该字符第一次出现的索引
    //lastIndexOf是返回s字符串中该字符最后一次出现的索引
    //执行用时：25ms,内存消耗：41.7MB
    public int firstUniqChar2(String s) {
        if(s.length()==1)
            return 0;
        for (int i = 0; i < s.length(); i++) {
            if(s.indexOf(s.charAt(i))==s.lastIndexOf(s.charAt(i)))
                return i;
        }
        return -1;
    }

4、字母异位词

​ 这题一开始想的解决办法是，使用两个map集合存储key和value，然后遍历map,进行比较value的值。value值相同就是字母异位词。但是力扣测试用例的最后一个用例并没有通过。最后看了题解，显然是我有点想复杂了。
​ 方法一：可以用一个int型数组存储26个字符出现的次数，当遍历另一个字符串时，就将这个int行数组的元素值进行–操作，最后再遍历这个数组，判断元素值是否为零，来判断是否为字母异位词。

    //方法一
    //使用一个int型数组存储字符串中单个字符的数量
    //最后再遍历另一个字符串的时候进行--,如果数组的元素为0，则证明为字母异位词
    //执行用时:3ms，内存消耗:41.2MB
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length())
            return false;
        int[] letCount = new int[26];
        for (int i = 0; i < s.length(); i++) {
            letCount[s.charAt(i) - 'a']++;
        }
        for (int i = 0; i < t.length(); i++) {
            letCount[t.charAt(i) - 'a']--;
        }
        for (int count :
                letCount) {
            if (count != 0)
                return false;
        }
        return true;
    }

​ 方法二：经典的就是先进行排序，然后再比较元素是否相同。

    //方法二
    //先排序再比较，比较元素是否相同
    //执行用时：4ms，内存消耗：41，5MB
    public boolean isAnagram2(String s, String t) {
        if (s.length() != t.length())
            return false;
        char[] chars = s.toCharArray();
        char[] chars1 = t.toCharArray();
        Arrays.sort(chars);
        Arrays.sort(chars1);
        return Arrays.equals(chars,chars1);
    }