Leecode初级——字符串篇1（反转字符串、整数反转、 字符串中的第一个唯一字符）

/*1.反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1：
输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例 2：
输入：["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]
*/
    public void reverseString(char[] s) {
        int len=s.length;
        char tmp;
        for (int i=0;i<len/2;++i){
            tmp=s[i];
            s[i]=s[len-1-i];
            s[len-1-i]=tmp;
        }
    }
/*=================================================================================
2.整数反转1* 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
 示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231,  231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
* */
    public int reverse(int x) {
        List<Character> tmpList= new ArrayList<>();
        int tmp;
        int len;    //tmpList长度
        int result=0;   //结果
        int index=0;    //索引号，便于tmpList使用
        boolean navFlag=false;//判断是否为负数
        while (x!=0){
            if (x<0){
                tmpList.add('-');
                x=x*(-1);
                navFlag=true;
            }

            tmp=x%10;
            tmpList.add((char) tmp);
            x/=10;
        }
        len=tmpList.size();
        if (len>10) return 0;
        if (navFlag){
            --len;
            index=1;
        }
        for (int i=len-1;i>=0;--i){
            result= (int) (result+((int)tmpList.get(index))*Math.pow(10,i));
            ++index;
        }
        if (navFlag)    result=result*(-1);
        if (result>Integer.MAX_VALUE||result<Integer.MIN_VALUE) return 0;
        return result;

    }
    /*整数反转2*/
    public int reverseInteger(int n) {
        String flag=n>=0?"":"-";
        char[] num = (Math.abs(n)+"").toCharArray();
        //int 最大值是2的32次方  21亿 大于10位置就不用考虑了
        if(num.length>10){
            return 0;
        }
        //翻转char数组
        int start=0;
        int end = num.length-1;
        while(start<end){
            char temp = num[start];
            num[start]=num[end];
            num[end]=temp;
            start++;
            end--;
        }

        //处理0的情况   12300->00321
        String reverseStr = new String(num);
        if(reverseStr.charAt(0)=='0'){
            int k=0;
            while(k<reverseStr.length()-1&&reverseStr.charAt(k)==0){
                k++;
            }
            reverseStr=reverseStr.substring(k);
        }

        //处理大于2的32 并且还为10位的情况，int最大2147483647
        Long overNum= Long.valueOf(reverseStr);
        if(overNum>Integer.MAX_VALUE){
            return 0;
        }

        //拼接前边的标志位
        reverseStr=flag+reverseStr;
        return Integer.valueOf(reverseStr);
    }

/*====================================================
3.字符串中的第一个唯一字符
给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
案例:
s = "leetcode"
返回 0.
s = "loveleetcode",
返回 2.
注意事项：您可以假定该字符串只包含小写字母。*/
    public int firstUniqChar(String s){
        char[] chars=s.toCharArray();
        int len=chars.length;
        int counter;
        for (int i=0;i<len;++i){
            counter=1;
            for (int j=i+1;j<len;++j){
                if (chars[i]==chars[j]) ++counter;
                if (counter==2) continue;
            }
            if (counter==1) return i;
        }
        return -1;
    }

    public int firstUniqChar2(String s){//用一个LinkedHashMap实现，key为字母，value如果第一次插入存入索引，再次插入存-1，然后遍历HashMap，找到第一个不是-1的value（LinkedHashMap保证了插入顺序，所以找到的一定是第一个唯一字符）。
        Map<Character,Integer> linkedHashMap=new LinkedHashMap<Character, Integer>();
        char cha;
        for (int i=0;i<s.length();++i){
            cha=s.charAt(i);
            if (linkedHashMap.containsKey(cha)){
                linkedHashMap.put(cha,-1);
            }
            else linkedHashMap.put(cha,i);//i作为索引
        }
        Iterator iterator=linkedHashMap.entrySet().iterator();
        Map.Entry<Character,Integer>entry;
        while (iterator.hasNext()){
            entry=(Map.Entry)iterator.next();
            if (entry.getValue()==-1)
                continue;
            return entry.getValue();
        }
        return -1;
    }
    public int firstUniqChar3(String s){//由于这里只有小写字母且ASCII码是连续的，于是可以把数组当作hash表用
        int[]cha=new int[26];
        char tmp;
        for (int i=0;i<s.length();++i){
            tmp=s.charAt(i);
            cha[(tmp-'a')]++;
        }
        for (int i=0;i<s.length();++i){
            tmp=s.charAt(i);
            if (cha[(tmp-'a')]==1)
                return i;
        }
        return -1;
    }