public class IsStringRepeat {

    /**
     * 判断字符串是否重复，假设字符串只有ASCII码，字符最多256个
     * @param str
     */
    private static boolean isStringRepeatAsc(String str){
        if (str.length() > 256){
            return false;
        }

        int[] strCount = new int[256];
        for (int i = 0; i< str.length(); i++) {
            int asc_index = (int)str.charAt(i);
            if (strCount[asc_index] != 0){
                return false;
            }
            strCount[asc_index] += 1;
        }
        return true;
    }

    /**
     * 假设字符串时unicode码，字符串很多，无法通过长度判断
     * @param str
     */
    private static boolean isStringRepeatUnicode(String str){
        if (null == str || "" == str){
            return false;
        }

        for (int i=0; i<str.length()-1;i++){
            for (int j=i+1;j<str.length();j++){
                if (str.charAt(i) == str.charAt(j)){
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * 
     * @param str
     * @return
     */
    private static boolean isStringRepeatUnicode2(String str){
        if (null == str || "" == str){
            return false;
        }
        char[] strArray = str.toCharArray();
        Arrays.sort(strArray);

        for (int i=0;i<strArray.length-1;i++){
            if (strArray[i] == strArray[i+1]){
                return false;
            }
        }

        return true;
    }

    public static void main(String[] args) {
        boolean result1 = isStringRepeatAsc("123456789 ert");
        boolean result2 = isStringRepeatUnicode2("123 ewqq");
    }
}

如何判断字符串是否包含重复字符
一种以时间换空间的方法
"""
判断一个字符串是否重复字符 例如：good就包含重复字符 而abc就不包含重复字符串
"""
def isDup(strs):
    lens = len(strs)
    i = 0
    while i < lens:
        j = i + 1
        while j < lens:
            if list(strs)[j] == list(strs)[i]:
                return True
            j += 1
        i += 1
    return False


if __name__ == '__main__':
    strs = 'abcdefghijk'
    res = isDup(strs)
    print(res)

这是比较简单的题目，上面的实现方法时间复杂度是O(n**2)，如何才能降低时间复杂度呢？思考一下。

简单题目

判断一个字符串中是否含有重复字符
#include <iostream>
#include <string>
 
using namespace std;
 
int main()
{
    string s;
    cin >> s;
    int checker = 0;
 
    for (int i = 0; i < s.length(); i++)
    {
        int val = s[i] - 'a'; //把a-z的字符, 转换成 0-25的数字
        if ((checker & (1<<val)) > 0)  // (1<<val)即得到对于bit位上的mask.  然后与 checker的位相与, 看是否为1
        {
            cout << "N" << endl;  //为1, 说明已经出现过
            return 0;
        }
        checker |= (1<<val);  //否则把这一位 置1
    }
 
    cout << "Y" << endl;
}

注：mask用得非常的秀。

需求：
实现一个算法确定字符串中的字符是否均唯一出现。

给出"abc"，返回 true
给出"aab"，返回 false


分析：
思路一：
判断字符串是否有重复字符，类似于，删除数组中重复的数字

1、将字符串转成字符数组

2、使用Arrays.sort(char[])对字符数组进行排序，然后，逐个遍历整个排序后的数组，如果不是最后一个字符，并且如果当前字符和其后面的字符相同，那么就直接返回false，否则继续遍历，如果所有的元素和其后面都不相同或者已经遍历到最后一个字符了，就认为是没有重复字符，即返回true

3、另外，对于null或者长度是0的字符串，没有重复字符，返回true

思路二：
创建哈希表，遍历字符串，如果哈希表中不包含该字符，就添加进去，如果包含，就返回false，如果没有重复的字符，那么最后返回true。
思路三：
上述两种思路的均需要额外开辟空间，如果想不开辟空间，那么可以借助String.indexOf(char ch, int fromIndex)，遍历字符串中的字符，遍历到倒数第二个字符即可。对每个字符，判断其后是否有重复的字符即可，如果有就返回false，如果没有重复的字符，那么返回true。

代码：
public class Solution {
    /*
     * @param str: A string
     * @return: a boolean
     */
    public boolean isUnique(String str) {
        // write your code here
        /*
        //思路一
        //如果str是null，那么抛出异常
        if(str == null){
            throw new IllegalArgumentException("invalid parameters");
        }
        
        //如果str的长度是0或者1，那么没有重复字符，返回true
        if(str.length() == 0 || str.length() == 1){
            return true;
        }
        
        //将字符串转成字符数组
        char[] ch = str.toCharArray();
        
        //对数组进行排序
        Arrays.sort(ch);
        
        //遍历数组，看当前字符是否和后面字符相同，相同就返回false，否则返回true
        for(int i = 0; i < ch.length-1; i++){
            if(ch[i] == ch[i+1]){
                return false;
            }
        }
        
        return true;
        */
        
        /*
        //思路二
        //如果str是null，那么抛出异常
        if(str == null){
            throw new IllegalArgumentException("invalid parameters");
        }
        //如果str的长度是0或者1，那么没有重复字符，返回true
        if(str.length() == 0 || str.length() == 1){
            return true;
        }
        
        //创建hash表，将字符串字符存到hash表中
        HashSet<Character> hs = new HashSet<Character>();
        
        for(int i = 0; i < str.length(); i++){
            if(hs.contains(str.charAt(i))){
                return false;//hash表中有相同的字符，那么说明有重复的字符
            }
            
            hs.add(str.charAt(i));
        }
        
        return true;
        */
        
        //思路三
        //如果str是null，那么抛出异常
        if(str == null){
            throw new IllegalArgumentException("invalid parameters");
        }
        //如果str的长度是0或者1，那么没有重复字符，返回true
        if(str.length() == 0 || str.length() == 1){
            return true;
        }
        
        //从前向后遍历字符串，对每个字符，调用String.indexOf()看其后面是否有相同的字符，如果有返回false，否则最后返回true
        for(int i = 0; i < str.length()-1; i++){
            if(str.indexOf(str.charAt(i), i+1) != -1){
                return false;
            }
        }
        
        return true;

    }
}