记录一下字符串处理的问题

问题一：找出两串字符串是否存在相同字符。

　　思路一：类似两个集合找相同元素一般，以一个集合为基准便利两个集合，遇到相同元素就中断，这样的时间代价是O（n2）平方级别，效率较低，也是最容易想到的方法。

public boolean StringSearch1(String s){
		boolean same=false;
		char[] chSet=new char[s.length()];
		s.getChars(0, s.length(), chSet, 0);
		for(int i=0;i<chSet.length;i++)
		{
			boolean bSignal=false;
			for(int j=0;j<chSet.length;j++)
			{
				if(j!=i)
					if(chSet[i]==chSet[j])
					{
						same=true;
						bSignal=true;
						break;
					}

			}
			if(bSignal)
				break;
		}

		return same;
	}

　　思路二：利用java的map映射存储字符，遇到相同的key值比较value，并设置为相同后退出。map映射与散列表的思想是一样的，需要运用空间换取时间以达到O（n）的效率，但是另需O（n）的空间来存储。这是一个比较好的方法，不过随着数据量的增大会给存储服务带来很巨大的性能损耗。

	public boolean StringSearch2(String s)
	{
		boolean same=false;
		Map<Character, Boolean> map=new HashMap<Character, Boolean>();
		for(int i=0;i<s.length();i++)
		{
			if(map.get(s.charAt(i))==null)
				map.put(s.charAt(i), true);
			else
			{
				same=true;
				break;
			}
		}

		return same;
	}

　　思路三：我们了解到有信息指纹这种简化信息本身存储空间的方法，并了解到通过信息指纹计算可以单独辨别一个信息，而且计算出来的指纹重复率十分之低。透过这个思想，我们想到每个字符都在系统中存在一个ASCII码，他们是互不相同的一个整形数（也可以说是二进制数），以此为基础建立A-Z，a-z的字典byte数组，然后以散列的方式存储并找出相同元素。（进一步优化就是位映射了，把一个byte=8个bit进行1变8的存储）。效率可达到O（n）。

//A-Z 65-90 a-z 97-122
	public boolean StringSearch3(String s)
	{
		boolean same=false;
		byte[] map =new byte[52];
		for(int i=0;i<map.length;i++)
			map[i]=0;
		for(int i=0;i<s.length();i++){
			char c=s.charAt(i);
			int code=(int)c;
			if(code<=90 && code>=65)
			{
				if(map[code-65]==1)
				{
					same=true;
					break;
				}else
					map[code-65]=1;
			}else if(code >=97 && code <=122)
			{
				if(map[code-97+26]==1){
					same=true;
					break;
				}else
					map[code-97+26]=1;
			}

		}
		return same;
	}

问题二：实现字符串反转

　　在这个问题上我并没有能想到更好的方法，只有新建一个同等长度的字符串并对位转存。

	public String StringReserve1(String s) throws UnsupportedEncodingException
	{
		int length=s.length();
		byte[] b1=s.getBytes();
		byte[] b2=new byte[length];
		for(int i=0;i<length;i++){
			b2[i]=b1[length-i-1];

		}
		String reS=new String(b2,"utf-8");
		return reS;
	}

int LengthOfStr(const char *c){
    const char *p=c;
    int len=0;
    while(*p!=‘\0‘){
        len++;
        p++;
    }

    return len;
}
const char * reverseStr(const char *c){
    char* reverStr;
    int len=LengthOfStr(c);
    reverStr=new char(len);
    for(int i=0;i<len;i++)
        *(reverStr+i)=*(c+len-1-i);
    return reverStr;
}