map与set容器初识：初步运用map与set

前言：

本文主要讲解的时对于map与set容器的初步使用，希望大家对map与set容器不熟悉的看了之后可以快速运用set与map到日常中来。（本文适合对vector等基础容器有一定基础的同学）

一、set与map容器常见接口

迭代器接口与以往的所有容器一样，同样的构造方法，同样的名称。

empty判断容器是否为空，size返回当前容器的大小，max_size返回容器的最大大小是多少，我们常用的是前两个接口，max_size一般情况下不会接触。

值得一提是map容器的operator[]，这个函数在调用时服用了insert的功能，当当前key值的元素不存在时，会插入一个当前键值元素，并返回新插入的元素地址。如果存在该key值，就返回该key值的地址。

二者都用insert函数来插入，在学了右值引用后，也可以用emplace来进行插入工作（操作与insert一样）。

之后的clear清空容器，swap交换两个容器内容，erase删除某个元素的操作都与其他容器差不多，包括find查找，count判断有无。要注意的是二者的范围查找接口，

对于二者的lower_bound(key); 都会返回第一个不小于 key 的迭代器。upper_bound(key); 都会返回第一个大于 key 的迭代器。

其实，在日常刷题做题中，我们的常用操作就是新建一个set或者mao容器，然后根据题目规则存储信息（set太棒用于去重排序，map用来记录两种数据之间的关联）在使用map时，我们也不会特地使用insert来进行插入，一般会直接在容器名后面[]键值，自动进行插入或者修改操作。

多说没用，实践才是最好的老师，接下来就让我带领大家做几道题应用一下map与set吧。

二、实战运用

1、随机链表的复制

（题目链接：https://leetcode.cn/problems/copy-list-with-random-pointer/description/）

在没有学习map与set之前，我们是怎么解决这道题的呢？

对于这道题来讲，难点在于怎么深拷贝random 所指向的节点因为我们没有与之对应的映射关系。

以例1为例，当我们拷贝了一个新链表之后，新的13节点的random指针所指向的 7，我们是没有存储的信息的，也就是找不到新链表上的7的地址。为了解决这个问题，我们将新链表插入在老链表之间，比如老1,13之间夹着一个新7.通过让next指向新拷贝的结点，让二者产生联系。在分开链表之间，只需要通过pcur->next->random=pcur->random->next就能得到解决。

class Solution 
{
public:
    Node* copyRandomList(Node* head) 
    {
        if (head == nullptr)
        {
            return nullptr;
        }

        Node* cur = head;
        while (cur)//先复制节点并连接点原本链表中
        {
            Node* pcur = new Node(cur->val);
            pcur->next = cur->next;
            cur->next = pcur;
            cur = pcur->next;
        }

        
        cur = head;
        while (cur != nullptr)
        {
            if (cur->random != nullptr)
            {
                cur->next->random = cur->random->next;
            }
            else
            {
                cur->next->random = nullptr;
            }
            cur = cur->next->next;
        }

        Node* phead = head->next, * prew = head;
        cur = phead;

        while (cur)
        {
            prew->next = cur->next;
            prew = prew->next;
            if (prew == nullptr)
            {
                cur->next = nullptr;
                cur = cur->next;
            }
            else
            {
                cur->next = prew->next;
                cur = cur->next;
            }
        }
        return phead;
    }
};

但是在有了map之后，就不用这么麻烦。只需要新建一个map，key为老节点，val为新的对应节点，就可以轻松完成代码。

class Solution 
{
public:
    Node* copyRandomList(Node* head)
     {
        map<Node*,Node*>Map;
        Node*cur=head,*copyhead=nullptr,*copytail=nullptr;
        while(cur)//cur遍历原链表进行拷贝并且把原链表与拷贝链表一一插入进map
        {
            if(copytail==nullptr)
            {
                copyhead=copytail=new Node(cur->val);
            }
            else
            {
                copytail->next=new Node(cur->val);
                copytail=copytail->next;
            }
            Map[cur]=copytail;
            cur=cur->next;
        }

        cur=head;
        Node* copy=copyhead;
        while(cur)
        {
            if(cur->random==nullptr)
            {
                copy->random=nullptr;
            }
            else
            {
                copy->random=Map[cur->random];//直接从map表中找到相应的节点地址
            }
            cur=cur->next;
            copy=copy->next;
        }
        return copyhead;
    }
};

2、环形链表2

（题目链接：https://leetcode.cn/problems/linked-list-cycle-ii/solutions/441131/huan-xing-lian-biao-ii-by-leetcode-solution/）

对于该题，在学习set与map之前我们通常用快慢指针法解决，由于数学原理与图形关系，倘若有环，快慢指针必定相遇，因此可以反向求出第一个入环节点的位置。

ListNode* hasCycle(struct ListNode* head)
{
    if (head == NULL || head->next == NULL)//当传过来的链表是空链表，或者传来的只有一个节点，且指向为空，说明不是环
    {
        return NULL;//返回false
    }
    ListNode* pcur = head, * ptail = head;
    while (ptail->next && ptail->next->next)//ptail->next与ptail->next->next其中有一个为假，就说明该指针有尽头，不是环
    {
        ptail = ptail->next->next;//快慢指针，如果相遇了，说明必有环,不相遇则一定有尽头
        pcur = pcur->next;
        if (ptail == pcur)
        {
            return ptail;//返回相遇点地址
        }
    }
    return NULL;
}

 struct ListNode* detectCycle(struct ListNode* head)
 {
     //如果有环，先找到相遇点
     ListNode* meet = hasCycle(head);
     if (meet == NULL)
     {
         return NULL;
     }
     //说明有环
     //快指针速度为慢指针两倍，快指针所走的路程为慢指针两倍，画出路程图可以列出关系式：当fast从相遇点出发，slow从head出发，速度相同，路程相同
     //会同时到达第一个相交节点
     ListNode* slow = head;

     while (slow != meet)
     {
         slow = slow->next;
         meet = meet->next;
     }
     return meet;
 }

但我们现在可以用set来记录出现过的链表节点，轻松解决问题。

class Solution 
{
public:
    ListNode *detectCycle(ListNode *head) 
    {
        
        set<ListNode *>Set;
        ListNode*ret=nullptr,*cur=head;
        while(cur)
        {
            bool Find=Set.insert(cur).second;
            if(Find==false)
            {
                ret=cur;
                break;
            }
            cur=cur->next;
        }
        return ret;
    }
};

二者代码复杂度一看便知。

3、前K个高频单词

（题目链接：https://leetcode.cn/problems/top-k-frequent-words/description/）

在我们看见第k大，前k个这样的关键字时，我们就想到了这是一个topk问题，自然也可以用优先级队列解决。但我们这里可以结合map的性质，与仿函数相结合解决问题。

我们可以用一个一个 map<string, int> Map，用于统计每个单词的出现次数。string 是单词，int 是该单词的出现频率。

随后使用 for (auto it : words) 遍历 words 数组，对于每个单词，将其频率在 Map 中加 1。这个循环完成后，Map 中存储了每个单词对应的出现频率。

接下来再缔造一个vector<pair<string, int>>，用来我们对pair进行排序，所以我们要添加仿函数来排序pair对象。

class Solution
{
public:
    struct Compare
    {
        bool operator()(const pair<string, int>& a, const pair<string, int>& b)
        {
            /*return a.second > b.second || (a.second == b.second && a.first < b.first);*/
            return a.second > b.second ;
        }
    };
    vector<string> topKFrequent(vector<string>& words, int k)
    {
        map<string, int>Map;
        vector<string>ret;
        for (auto it : words)
        {
            Map[it]++;
        }

        vector<pair<string, int>>arr(Map.begin(), Map.end());
     /*   sort(arr.begin(), arr.end(), Compare());*/
        stable_sort(arr.begin(), arr.end(), Compare());
        for (int i = 0; i < k; ++i)
        {
            ret.push_back(arr[i].first);
        }
        return ret;
    }
};

我这里的代码结合了map本身对key键值对就进行了字典序排序，所以我们后面才使用稳定的stable_sort，这样就算两个key的val相同，二者的字典序相对顺序也不会改变。。如果我们要使用sort，就需要在仿函数中加上对val值相同，比较字典序的判断条件。

4、单词识别

（题目链接;http://https://www.nowcoder.com/practice/http://https://www.nowcoder.com/practice/）

对与此题，我们也可以类似的用map来存储单词与出现频率的关系。

为了能够接受一句话，所以我们要用getline来接受而不是cin。

#include <iostream>
using namespace std;
#include<map>
#include<algorithm>
#include<string>
#include<vector>

struct Compare
{
    bool operator()(const pair<string,int>&a,const pair<string,int>&b)
    {
        return a.second>b.second;
    }
};

int main()
{
    string s;
    map<string,int>Map;
    getline(cin,s);

    char*ch;
    for(int i=0;i<s.size();++i)
    {
        string ss;
        while(s[i]!=' ')
        {
            if(s[i]=='.')
            {
                break;
            }

            ss+=tolower(s[i++]);
        }
        Map[ss]++;
    }


    vector<pair<string,int>>arr(Map.begin(),Map.end());
    stable_sort(arr.begin(),arr.end(),Compare());
    for(auto it:arr)
    {
        cout<<it.first<<":"<<it.second<<endl;
    }
    return 0;
}

三、总结

在本文中，我们通过多个实际例题，深入探讨了 map 和 set 容器的常见操作和实际应用。这些容器在处理数据的过程中能够提供强大的支持，尤其在涉及到元素的唯一性、快速查找和数据关联的场景下。

1. 基本操作与接口

我们首先回顾了 map 和 set 容器的基本操作，包括元素插入、查找、删除等常用接口。在日常的算法题解中，这些基本操作为我们提供了便捷的工具。例如，使用 map 记录元素之间的关联关系，利用 set 处理去重和排序问题。

2. 实战应用

我们通过几个经典的算法题，展示了如何在实际编程中运用 map 和 set 容器。通过这些案例，我们看到了这些容器在不同场景下的灵活性和高效性：

随机链表的复制：利用 map 建立新旧节点之间的映射关系，简化了链表的深拷贝操作。
环形链表检测：通过 set 记录已经访问过的节点，轻松找到链表中的环。
前K个高频单词：结合 map 统计频率和仿函数排序，快速找到出现频率最高的单词。
单词识别：使用 map 统计句子中每个单词的频率，并按出现次数进行排序，展示了 map 的实用性。

3. 稳定排序的应用

在排序过程中，我们强调了 stable_sort 的使用，这对于保持排序的稳定性尤为重要。在某些题目中，我们需要确保排序过程中，相同频率的单词按字典序排列，而 stable_sort 正是保证这种稳定性的关键。

4. 代码复杂度与性能

通过与传统方法的比较，我们可以看到使用 map 和 set 后，代码复杂度得到了简化，逻辑更为清晰。虽然这些容器的底层实现较为复杂，但它们提供的高效查找和插入性能，使得我们在解决实际问题时受益匪浅。

结语

学习 map 和 set 容器不仅仅是掌握其基本用法，更重要的是通过实践，理解它们在不同场景中的应用和优势。本文的示例和解析，希望能帮助读者更好地掌握这些工具，并在今后的算法和编程实践中更加得心应手。通过不断练习，读者可以熟练地将 map 和 set 应用于各种复杂的数据处理任务中，从而提升编程效率和代码质量。