[编程题]确定两串乱序同构的几种解答方式

题干：给定两个字符串，请编写程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。这里规定大小写为不同字符，且考虑字符串重点空格。
给定一个string stringA和一个string stringB，请返回一个bool，代表两串是否重新排列后可相同。保证两串的长度都小于等于5000。
测试样例：
“This is nowcoder”,”is This nowcoder”
返回：true
“Here you are”,”Are you here”
返回：false

思路： 两个字符串能乱序同构，则字符串中所包含的每个字符的个数都完全相同！
解答1：
使用一个map来存储每个char出现的次数： map

class Same {
public:
    bool checkSam(string stringA, string stringB) {
        // write code here
        map<char,int> ACount;
        map<char,int> BCount;

        if(stringA.length() != stringB.length())
            return false;

        for(int i=0; i < stringA.length(); i++)
        {
            map<char,int>::iterator ite = ACount.find(stringA[i]);   //查找map中是否存在key值为stringA[i]的元素
            if( ite == ACount.end())    //若不存在，返回值为结尾迭代器
            {
                ACount.insert(pair<char,int>(stringA[i],1));//插入新的pair，计数值为0
            }
            else
                ite->second++;  //若存在，则将其计数值加1
        }
        for(int i=0; i < stringB.length(); i++)
        {
            map<char,int>::iterator ite = BCount.find(stringB[i]);
            if( ite == BCount.end())
            {
                BCount.insert(pair<char,int>(stringB[i],1));
            }
            else
                ite->second++;
        }
        map<char,int>::iterator iteA= ACount.begin();
        map<char,int>::iterator iteB= BCount.begin();
        for( ;iteA!= ACount.end() && iteB!= BCount.end(); )
        {
            if(!( iteA->first == iteB->first && iteB->second && iteB->second)) //比较是否相等
                return false;
            iteB++;
            iteA++;
        }
        return true;
    }
};

解答2

//有点无耻额，直接用的sort函数,虽然简洁，复杂度却是O(nlogn);
//正规的做法，应该是hash，用256的元素记录每个字符出现的次数
//再进行比较，扫描一遍，比较一遍，复杂度只要O(n).
class Same {
public:
    bool checkSam(string stringA, string stringB) {

        sort(stringA.begin(),stringA.end());
        sort(stringB.begin(),stringB.end());
        return stringA.compare(stringB)==0;
    }
};