数据结构与算法以及刷题leetocde 007 查找表 set和map相关

之前都是数组的操作，接下来介绍的数据结构是set，map, set 和map是C++中的容器；

首先复习一下set的基本使用，set数据结构内的数据是没有重复数据的,unique

#include
#include
using namespace std;
int main()
{
    int i;
    int arr[5] = {0,1,2,3,4};
    set iset(arr,arr+5);

    iset.insert(5);
    cout<<"size:"<

基本操作是insert(),erase(),find(),change(map)改变map中的值的函数，由于C++中是使用二分搜索树来实现set和红黑树来实现map所以插入，删除，查找的时间复杂度都是O(log(n))

关于集合的操作使用leetcode中的题型有：

leetcode 349:求解两个数组的交集

class Solution {
public:
    vector intersection(vector& nums1, vector& nums2) {
        //使用集合数据结构
        set unique(nums1.begin(),nums1.end());
        set ans;
        int i=0;
        int size=nums2.size();
        for(i=0;i result(ans.begin(),ans.end());
        return result;
        
    }
};

时间复杂度为O（nlogn）

算法改进：使得时间复杂度为O（n）,这时就需要用到两种数据结构 unordered_set和unordered_map，这两种数据结构的底层实现是通过hash表来实现的，所以插入和查找的时间复杂度为O（1）

class Solution {
public:
    vector intersection(vector& nums1, vector& nums2) {
        //使用集合数据结构
        unordered_set unique(nums1.begin(),nums1.end());
        unordered_set ans;
        int i=0;
        int size=nums2.size();
        for(i=0;i result(ans.begin(),ans.end());
        return result;
        
    }
};

以下是C++中map的基本使用，同样map的底层实现是通过二分搜索树实现的；

//插入元素：
//用insert函數插入pair，成对的插入剪枝对的方式来构建
    mapStudent.insert(pair("r000", "student_zero"));
 
//用"array"方式插入
    mapStudent["r123"] = "student_first";
    mapStudent["r456"] = "student_second";

C++中map有点类似于Python中defaultDict高级数据结构，默认值为0

leetcode 350 求两个数的交集，返回含有重复类型的数据

class Solution {
public:
    vector intersect(vector& nums1, vector& nums2) {
       map maps;
        vector ans;
        int i=0;
        int size=nums1.size();
        for(i;i=0)
                    ans.push_back(nums2[j]);
            }
        }
        return ans;
    }
};

时间复杂度是O（nlog(n)）

算法优化：使用unordered_map来进行构建数据

将map改为unordered_map即可

leetcode242：判断一个字符串是否是自身变换的字符串

class Solution {
public:
    bool isAnagram(string s, string t) {
        //使员工查找表数据结构来实现相应 hash
    map maps;
    int i=0;
    int size=s.size();
    for(i;i::iterator iter=maps.begin();
    for(iter;iter!=maps.end();iter++){
        if(iter->second!=0){
            return false;
        }
    }
    return true;
    }
};

时间复杂度为O(nlogn)

同样将map改变unordered_map hash表的实现方式，时间复杂度为O(n)

leetcode202: 判断一个数是否是happy number，难点如何通过查找表来实现无限循环的退出

class Solution {
public:
    bool isHappy(int n) {
        //使用一个map来存储每次计算的值，如果出现了重复那么就输出false
        map maps;
        while(n!=1){
            int sum=countSum(n);
            if(sum==1){
                return true;
            }
            maps.insert(pair(n,sum));
            if(maps.count(sum)){//返回1或者0；;
                return false;
            }
            n=sum;
            
        }
        return true;
    }
private:
    int countSum(int n){
        int sum=0;
        while(n>0){
            int temp=n%10;
            sum+=temp*temp;
            n=n/10;
            
    }
        return sum;}
};

leetcode290: 判断两个字符串是否匹配；难点如何构建相互之间的映射

class Solution {
public:
    bool wordPattern(string pattern, string str) {
        //首先符字符串进行分词，然后构建相互的映射
        vector mystring=split(str);
        map mypatternMap;
        map mystringMap;
        int i=0;
        int size=pattern.size();
        if(pattern.size()!=mystring.size()){
            return false;
        }
        for(i;i(pattern[i],mystring[i]));
               mystringMap.insert(pair(mystring[i],pattern[i]));
            
           } 
            else if(mypatternMap[pattern[i]]!=mystring[i]||mystringMap[mystring[i]]!=pattern[i]){
                return false;
            }
        }
        return true;
    }
private:
    vector split(string str){
    int i=0;
    int size=str.size();
    vector ans;
    int j=0;
    for(i;i

时间复杂度为O（nlog(n)）,插入元素的时间复杂度为O（log(n)）

同理leetcode205 也是相应的方式，通过构建hashTable，查看两个字符串是否是结构匹配；

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        if(s.size()!=t.size()){
            return false;
        }
        map charMap1;
        map charMap2;
        for(int i=0;i(s[i],t[i]));
                charMap2.insert(pair(t[i],s[i]));
            }
            else if(charMap1[s[i]]!=t[i]||charMap2[t[i]]!=s[i]){
                return false;
            }
        }
        return true;
    }
};

时间复杂度为O(nlog(n))

接下来是leetcode451  Sort Characters By Frequency 按照字符出现的次数进行排序，返回排序后的字符串（核心就是如何对map中的值进行排序）,使用数组，数组中的元素是pair类型的数据

class Solution {
public:
    string frequencySort(string s) {
        //首先构建一个map来存储相应的hash结构，统计出现的频次
        map myMap;
        int i=0;
        int size=s.size();
        for(i;i::iterator iter=myMap.begin();
        // for(iter;iter!=myMap.end();iter++){
        //     int j=0;
        //     while(jsecond){
        //         ans+=iter->first;
        //         j++;
        //     }
        // }
        // return ans; 以上算法不行 首先将pair元素push_back 到vector 中
        vector> temp;
        map::iterator iter=myMap.begin();
        for(iter;iter!=myMap.end();iter++){
            temp.push_back(pair(iter->first,iter->second));
        }
        sort(temp.begin(),temp.end(),paixu);
        int size2=temp.size();
        string ans="";
        for(int i=0;i& map1,  const pair& map2){// 需要static 否则不能通过；
        return map1.second>map2.second;
        }
};

leetcode1 也可以用HashTable来实现，时间复杂大大降低

class Solution {
public:
    vector twoSum(vector& nums, int target) {
        //使用hashtable 
        int i=0;
        int size=nums.size();
        map myMap;
        vector result;
        for(i;isecond);
                    result.push_back(i);
                    return result;
                }
            }
            myMap[nums[i]]=i;//
            
        }
        
        map::iterator iter=myMap.begin();
        for(iter;iter!=myMap.end();iter++){
            if(myMap.find(target-iter->first)!=myMap.end()){
                map::iterator iter2=myMap.find(target-iter->first);
                result.push_back(iter->second);
                result.push_back(iter2->second);
                return result;
            }
            }
        
        return result;
    }
};

时间复杂度为O(nlogn)，空间复杂度为O（n）,运行时间13ms

如果将map换成unordered_map输出错误的结果？？ 有谁知道为什么吗？

leetcode76:滑动窗口的经典题型，非常的经典真的是，这里贴一个相应的网址：

解释的相当的好

https://blog.csdn.net/u013115610/article/details/70257445