随手写 4/2

4 字符串的切割
# include<sstream>

vector<string> strSplit(string str, char delim) {
	std::stringstream ss(str;
	std::vector<string> res;
	string item;
	while(getline(ss, item, delim)) {
		res.push_back((item));
	}
	return res;
}

 hash_table的生成于遍历,STL的 MAP 实现是红黑树，unorder_map实现则是 hash 链表实现

std::vector<ListNode*> vec;
ListNode* hash_table[100] = {0};
//table 长度为质数，可以减少冲突
const table_len = 11;
 int getHashKey(int val, int table_len) {
 	return val%table_len;
 }

void insert(ListNode* hashtable[], ListNode* node, int table_len) {
	int hash_key = getHashKey(node->val, table_len);
	node->next = hashtable[hash_key];
	hashtable[hash_key] = node;
}

bool search(ListNode* hashtable[], int value, inr table_len) {
	int hash_key = getHashKey(value, table_len);

	ListNode* head = hashtable[hash_key];
	while(head) {
		if (head->val == value) {
			return true;
		}
		head = head-next;
	}
	return false;
}

3 字符串是够符合给定序列
给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。

这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例1:

输入: pattern = "abba", str = "dog cat cat dog"
输出: true
主要是利用两个 map 实现一对一映射，检查是否相互使用了
void strSplit(string str, vector<string> &res) {
    string item;
    stringstream ss(str);
    while(getline(ss, item, ' ')){
        res.push_back(item);
    }
}

bool wordPattern(string pattern, string str) {
    vector<string> str_list;
    //先切割
    strSplit(str, str_list);
    if (pattern.size() != str_list.size()) {
        return false;
    }
    if(str_list.size() == 0) {
        return true;
    }
    
    map <string, char > m_s;
    map <char, string> m_p;
    //利用俩 map 相互映射
    m_s[str_list[0]] = pattern[0];
    m_p[pattern[0]] = str_list[0];
    for (int i = 1;i<str_list.size();i++) {
        map<string, char> ::iterator it = m_s.find(str_list[i]);
        //如果如果分割的字符出现了而且对应的 pattern 字符不是存储的那个，就 false
        if (it != m_s.end() && it->second != pattern[i]) {
            return false;
        } else if (it == m_s.end()) {
            map<char, string> ::iterator it1 = m_p.find(pattern[i]);
             //如果没出现，就要看看对应的 pattern在另一张映射表出现了么，如果出现了，说明这个对应的 pattern 字符被占了，false
            if(it1 != m_p.end()) {
                return false;
            } else {
            //双方都没出现，则存储
                m_s[str_list[i]] = pattern[i];
                m_p[pattern[i]] = str_list[i];
            }
        }
    }
    return true;
}

string  assign 相关
string &operator=(const string &s);　　  　　　　　　　　　　　把字符串s赋给当前字符串
string &assign(const char *s);　　　　　　　　　　　　　　　　　用c类型字符串s赋值
string &assign(const char *s,int n);　　　　　　　　　　　　　 用c字符串s开始的n个字符赋值
string &assign(const string &s);　　　　　　　　　　　　　　　  把字符串s赋给当前字符串
string &assign(int n,char c);　　　　　　　　　　　　　　　　　 用n个字符c赋值给当前字符串
string &assign(const string &s,int start,int n);　　　　　　 把字符串s中从start开始的n个字符赋给当前字符串
string &assign(const_iterator first,const_itertor last);　　把first和last迭代器之间的部分赋给字符串