面试笔试算法-STL容器的使用与练习

最新推荐文章于 2024-02-18 13:55:33 发布

期待┌;崛起、~~

最新推荐文章于 2024-02-18 13:55:33 发布

阅读量283

点赞数

分类专栏： C&C++ leetcode 文章标签：算法

本文链接：https://blog.csdn.net/gjpzl/article/details/110621404

版权

leetcode 同时被 2 个专栏收录

32 篇文章 1 订阅

订阅专栏

C&C++

13 篇文章 0 订阅

订阅专栏

容器的使用:

queue:

类型 + 名, queue<int> que;

que.push(1); 入队
que.pop(); 出队
que.front(); 队首元素
que.size(); 元素个数
que.empty(); 是否为空

stack:

类型 + 名, stack<int> sta;

sta.push(1);
sta.pop();
sta.top(); 获得栈顶元素
sta.size();
sta.empty();

注:底层实现是双端队列(dequeue);

队列代码演示:

#include<iostream>
#include <queue>
using namespace std;
struct node {
    int x, y;
};
int main(int argc, char *grav[])
{
    queue<int> que;
    for (int i = 9; i > 4; i--) {
        que.push(i);
    }
    while (!que.empty()) {
        cout << "que.front() = " << que.front() << "\tque.size() = " << que.size() << endl;
        que.pop();
    }
    queue<node> que1;
    node a;
    a.x = a.y = 6;
    que1.push(a);
    que1.push((node){7, 8});
    cout << que1.front().x << endl;
    que1.pop();
    node temp = que1.front();
    cout << temp.x << " " << temp.y << endl;
    return 0;
}

栈的代码演示:

#include<iostream>
#include <stack>
using namespace std;
int main(int argc, char *grav[])
{
    stack<int> sta;
    for (int i = 9; i > 4; i--) {
        sta.push(i);
    }
    while (!sta.empty()) {
        cout << "sta.top() = " << sta.top() << "\tsta.size() = " <<  sta.size() << endl;
        sta.pop();
    }
    return 0;
}

vector:

类型 + 名 : vector<int> v;

v.push_back(5);后面插入
v.size(); 容器大小
v.insert(1, 6); 插入元素
vector<vector<int> > v2; 动态二维数组

priority_queue:

类型 + 名: priority_queue que;

que.push(5);
que.pop();
que.top();
que.size();
que.empty();

自定义类型如何使用:

需要自己重载<,(>不行):
struct node {
    int x, y;
    bool operator < (const node &b) {
        return this.x > b.x;
    }
};
priority_queue<node> que;
底层实现是堆.

vector代码演示:

#include<iostream>
#include <vector>
using namespace std;
int main(int argc, char *grav[])
{
    vector<int> v;
    for (int i = 105; i <= 110; i++) {
        v.push_back(i);
        cout << v.size() << endl;
    }
    for (int i = 0; i < v.size(); i++) {
        cout << v[i] << endl;
    }
    vector<vector<int> > v1;
    v1.push_back(vector<int>());
    for (int i = 66; i <= 70; i++) {
        v1[0].push_back(i);

    }
    v1.push_back(vector<int>(5, 0));
    vector<int> v2;
    v2.push_back(5);
    v2.push_back(6);
    v2.push_back(7);
    v1.push_back(v2);
    v1.push_back(vector<int>(10, 0));
    for (int i = 0; i < v1.size(); i++) {
        for (int j = 0; j < v1[i].size(); j++) {
            cout << v1[i][j] << "\t";
        }
        cout << endl;
    }
    return 0;
}

priority_queue代码演示:

#include<iostream>
#include <queue>
using namespace std;
struct node {
    int x, y;
    bool operator < (const node &b) const {
        return this->x > b.x;
    }
};
int main(int argc, char *grav[])
{
    priority_queue<int> que; // 默认从大到小
    que.push(10);
    que.push(20);
    que.push(5);
    que.push(6);
    que.push(1);
    while (!que.empty()) {
        cout << que.top() << endl;
        que.pop();
    }
    // 自定义结构
    priority_queue<node> que1;
    que1.push((node){1, 2});
    que1.push((node){2, 1});
    cout << que1.top().x << endl;
    que1.pop();
    cout << que1.top().x << endl;
    return 0;
}

string:

操作:

str.size()/str.length();长度
str.find(s2);在str中查找s2,返回下标值,第二个参数是从什么位置开始找,未找到返回值 == string::npos
str.insert(x, s2); // 在x位置插入s2
str.substr(2); //从下标2的位置开始截取,舍弃前面的字符
str.substr(2,2);// 从下标2开始截取2个字符
str.replace(x, y, s2); // 从x位置向后替换y个字符,替换成s2

map(键值对):

map<string, int> m;

[]
m[’“123”] = 456;
cout << m["123"] << endl;
insert
find
earse
count
multimap:可以有重复的键
unordered_map:hash表实现,无序的

map代码演示:

#include<iostream>
#include <map>
#include <string>
#include <unordered_map>
using namespace std;

struct node {
    int x, y;
    bool operator < (const node &b) const {
        return this->x > b.x;
    }
};

int main(int argc, char *grav[])
{
    // map
    map<string, int> m;
    string a = "123";
    m[a] = 999;
    cout << m["123"] << endl;
    cout << m[a] << endl;
    cout << m["456"] << endl;
    // 自定义结构
    map<node, int> m1;
    node a1;
    m1[a1] = 5;
    // unordered_map
    unordered_map<string, int> unmap;
    string b = "123";
    unmap[b] = 999;
    cout << unmap["123"] << endl;
    cout << unmap[a] << endl;
    cout << unmap["456"] << endl;
    return 0;
}

总结：

在这里插入图片描述

OJ-383.周末舞会

题目描述

假设在周末舞会上，X 名男士和 Y 名女士进入舞厅时，各自排成一队，并分别按顺序编号。跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴。规定每个舞曲只能有一对跳舞者。跳完舞的人回到队尾。输出前 N 首舞曲的跳舞者编号。

输入

一行三个数 X,Y,N。

输出

输出共 N 行，一行两个数，分别代表跳这支舞曲的男士编号和女士编号，两数之间用空格隔开。

样例输入

3 5 6

样例输出

代码演示:

#include<iostream>
#include <queue>
using namespace std;
int main(int argc, char *grav[])
{
    int x, y, n;
    cin >> x >> y >> n;
    queue<int> qx, qy;
    for (int i = 1; i <= x; i++) {
        qx.push(i);
    }
    for (int i = 1; i <= y; i++) {
        qy.push(i);
    }
    for (int i = 1; i <= n; i++) {
        cout << qx.front() << " " << qy.front() << endl;
        qx.push(qx.front());
        qy.push(qy.front());
        qx.pop();
        qy.pop();
    }
    return 0;
}

OJ-378 字符串括号匹配2

题目描述

给出一个字符串，判断其中的左右括号是否匹配。

注：需同时判断左右圆括号 ′(′ 和 ′)′ ，左右中括号 ′[′ 和 ′]′ ，左右大括号′{′ 和 ′}′。

不需要考虑括号之间的优先级的问题，也就是说，小括号包含大括号，也是被允许的。

输入

一行一个字符串，以字符@为结尾。

输出

若匹配，输出 YES，若不匹配，则输出 NO。

样例输入

a(cc[])bbb()@

样例输出

YES

样例输入2

a(cc[)]bbb()@

样例输出2

NO

代码演示:

#include<iostream>
#include <stack>
#include <string>
using namespace std;
int main(int argc, char *grav[])
{
    string s;
    cin >> s;
    stack<char> sta;
    for (int i = 0; i < s.size(); i++) {
        if (s[i] == '(' || s[i] == '[' || s[i] == '{') {
            sta.push(s[i]);
        } else if (s[i] == ')') {
            if (sta.empty() || sta.top() != '(') {
                cout << "NO" << endl;
                return 0;
            }
            sta.pop();
        } else if (s[i] == ']') {
            if (sta.empty() || sta.top() != '[') {
                cout << "NO" << endl;
                return 0;
            }
            sta.pop();
        } else if (s[i] == '}') {
            if (sta.empty() || sta.top() != '{') {
                cout << "NO" << endl;
                return 0;
            }
            sta.pop();
        }
    }

    if (sta.empty()) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }
    return 0;
}

Oj376机器翻译

题目描述

小李的电脑上安装了一个机器翻译软件，他经常用这个软件来翻译英语文章。

这个翻译软件的原理很简单，它只是从头到尾，依次将每个英文单词用对应的中文含义来替换。对于每个英文单词，软件会先在内存中查找这个单词的中文含义，如果内存中有，软件就会用它进行翻译；如果内存中没有，软件就会在外存中的词典内查找，查出单词的中文含义然后翻译，并将这个单词和译义放入内存，以备后续的查找和翻译。

假设内存中有 M 个单元，每单元能存放一个单词和译义。每当软件将一个新单词存入内存前，如果当前内存中已存入的单词数不超过 M−1，软件会将新单词存入一个未使用的内存单元；若内存中已存入 M 个单词，软件会清空最早进入内存的那个单词，腾出单元来，存放新单词。

假设一篇英语文章的长度为 N 个单词。给定这篇待译文章，翻译软件需要去外存查找多少次词典？假设在翻译开始前，内存中没有任何单词。

输入

共 2 行。每行中两个数之间用一个空格隔开。

第一行为两个正整数M,N，代表内存容量和文章的长度。

第二行为 N 个非负整数，按照文章的顺序，每个数（大小不超过 1000）代表一个英文单词。文章中两个单词是同一个单词，当且仅当它们对应的非负整数相同。

输出

一个整数，为软件需要查词典的次数。

样例输入

3 7
1 2 1 5 4 4 1

样例输出

样例说明

整个查字典过程如下：每行表示一个单词的翻译，冒号前为本次翻译后的内存状况：

空：内存初始状态为空。

1．1：查找单词1并调入内存。

2． 12：查找单词2并调入内存。

3． 12：在内存中找到单词1。

4． 125：查找单词5并调入内存。

5． 254：查找单词4并调入内存替代单词1。

6． 254：在内存中找到单词4。

7． 541：查找单词1并调入内存替代单词2。

共计查了5次词典。

思路：

在这里插入图片描述

队列结构
使用标记数组进行标记队列中是否存在
也可以使用map，set容器

代码演示:

#include<iostream>
#include <queue>
using namespace std;
int ans, n, m, mark[1005];
int main(int argc, char *grav[])
{
    cin >> m >> n;
    queue<int> que;
    for (int i = 0; i < n; i++) {
        int t;
        cin >> t;
        if (mark[t] == 0) {
            ans++;
            if (que.size() == m) {
                mark[que.front()] = 0;
                que.pop();
            }
            que.push(t);
            mark[t] = 1;
        }
    }
    cout << ans << endl;
    return 0;
}

Oj-379仓库日志

题目描述

某仓库购入新的货物（每次购入的货物均不同）并将一部分老货物发出，这个过程会有软件对数据以日志形式保存，规则如下：

该日志记录了两类操作：第一类操作为入库操作，以及该次入库的货物数量；第二类操作为出库操作。这些记录都严格按时间顺序排列。入库和出库的规则为先进后出，即每次出库操作货物为当前在仓库里所有货物中最晚入库的货物。

为了便于分析，现在加入了第三类查询操作，每次查询时，输出当前仓库数量最多的货物的数量。

输入

包含 N+1 行：

第一行为 1 个正整数 N，对应于日志内所含操作的总数。

接下来的 N 行，分别属于以下三种格式之一：

格式 1: 0 X //一次入库操作，正整数 XX 表示该次入库的货物的数量

格式 2: 1 //一次出库操作，（就当时而言）最后入库的货物出库

格式 3: 2 //一次查询操作，要求分析程序输出当前仓库内数量最多的货物的数量

当仓库为空时你应该忽略出库操作，当仓库为空查询时你应该输出 0。

初始时仓库状态为空。

输出

输出行数等于日志中查询操作的次数。每行为一个正整数，表示查询结果。

样例输入

样例输出

思路：

建一个极大值栈，每次最大的在上面

代码演示:

#include<iostream>
#include <stack>
using namespace std;

int main(int argc, char *grav[])
{
    int n;
    stack<int> g, mmax;
    cin >> n;
    for (int i = 0; i < n; i++) {
        int t;
        cin >> t;
        if (t == 0) {
            cin >> t;
            g.push(t);
            if (mmax.empty()) {
                mmax.push(t);
            } else {
                mmax.push(max(t, mmax.top()));
            }
        } else if (t == 1) {
            if (!g.empty()) {
                g.pop();
                mmax.pop();
            }
        } else if (t == 2) {
            if (g.empty()) {
                cout << 0 << endl;
            } else {
                cout << mmax.top() << endl;
            }
        }
    }
    return 0;
}

Oj-382报数

题目描述

N 个人围成一圈，编号分别为 1,2,3……N ,第一个人从 11 报数，按照编号顺序依次报数，报 M 的人会离开队伍，然后下一个人会继续从 1 开始报数，直到剩下一人，剩下的人的编号是多少？

输入

共一行两个数 N 和 M。

输出

输出一个数表示最后一人的编号。

样例输入

7 3

样例输出

思路:

使用队列,当前报的号等于m,就弹出,弹出后当前号置为1,否则放到队尾

代码演示:

#include<iostream>
#include <queue>
using namespace std;

int main(int argc, char *grav[])
{
    int n, m, now = 1;
    cin >> n >> m;
    queue<int> que;
    for (int i = 1; i <= n; i++) {
        que.push(i);
    }
    while (que.size() != 1) {
        if (now == m) {
            que.pop();
            now = 1;
        } else {
            que.push(que.front());
            now++;
            que.pop();
        }
    }
    cout << que.front() << endl;
    return 0;
}

Oj385-海港

题目描述

小李是一个海港的海关工作人员，每天都有许多船只到达海港，船上通常有很多来自不同国家的乘客。

小李对这些到达海港的船只非常感兴趣，他按照时间记录下了到达海港的每一艘船只情况；对于第 ii 艘到达的船，他记录了这艘船到达的时间 ti (单位：秒)，船上的乘客数 ki，以及每名乘客的国籍 xi,1,xi,2,…,xi,k。

小李统计了 n 艘船的信息，希望你帮忙计算出以每一艘船到达时间为止的 24 小时( 24 小时= 86400秒）内所有乘船到达的乘客来自多少个不同的国家。

形式化地讲，你需要计算 n 条信息。对于输出的第 i 条信息，你需要统计满足 ti−86400<tp≤ti 的船只 p，在所有的 xp,j 中，总共有多少个不同的数。

输入

第一行输入一个正整数 n，表示小李统计了 n 艘船的信息。

接下来 n 行，每行描述一艘船的信息：前两个整数 ti 和 ki 分别表示这艘船到达海港的时间和船上的乘客数量，接下来 ki 个整数 xi,j 表示船上乘客的国籍。

保证输入的 ti 是递增的，单位是秒；表示从小李第一次上班开始计时，这艘船在第 ti 秒到达海港。

输出

输出 n 行，第 i 行输出一个整数表示第 i 艘船到达后的统计信息。

样例输入1

3
1 4 4 1 2 2
2 2 2 3
10 1 3

样例输出1

3
4
4

样例输入2

4
1 4 1 2 2 3
3 2 2 3
86401 2 3 4
86402 1 5

样例输出2

样例说明1

第一艘船在第 1 秒到达海港，最近 24 小时到达的船是第一艘船，共有 4 个乘客，分别是来自国家 4,1,2,2，共来自 3 个不同的国家；

第二艘船在第 2 秒到达海港，最近 24 小时到达的船是第一艘船和第二艘船，共有 4+2=6 个乘客，分别是来自国家 4,1,2,2,2,3共来自 4 个不同的国家；

第三艘船在第 10 秒到达海港，最近 24 小时到达的船是第一艘船、第二艘船和第三艘船，共有 4+2+1=7 个乘客，分别是来自国家 4,1,2,2,2,3,3共来自 4 个不同的国家。

样例说明2

第一艘船在第 1 秒到达海港，最近 24小时到达的船是第一艘船，共有 4 个乘客，分别是来自国家 1,2,2,3，共来自 3个不同的国家。

第二艘船在第 3 秒到达海港，最近 24 小时到达的船是第一艘船和第二艘船，共有 4+2=6 个乘客，分别是来自国家 1,2,2,3,2,33，共来自 3 个不同的国家。

第三艘船在第 86401 秒到达海港，最近 24 小时到达的船是第二艘船和第三艘船，共有 2+2=4 个乘客，分别是来自国家 2,3,3,4共来自 3 个不同的国家。

第四艘船在第 86402 秒到达海港，最近 24 小时到达的船是第二艘船、第三艘船和第四艘船，共有 2+2+1=5 个乘客，分别是来自国家 2,3,3,4,5共来自 4 个不同的国家。

思路:

将人和随船到达的时间封装成一个结构体放在队列中,分别记录每次到达船只的人,计算国家数量即可.

代码演示:

#include<cstdio>
#include <queue>
using namespace std;
struct persion {
    int t, c;
};
int n, con, mark[100005];
int main(int argc, char *grav[])
{
    scanf("%d", &n);
    queue<persion> que;
    for (int i = 0; i < n; i++) {
        int at, pcnt;
        scanf("%d%d", &at, &pcnt);
        while (!que.empty() && at - que.front().t >= 86400) {
            mark[que.front().c]--;
            if (mark[que.front().c] == 0) {
                con--;
            }
            que.pop();
        }
        for (int j = 0; j < pcnt; j++) {
            int temp;
            scanf("%d", &temp);
            que.push((persion){at, temp});
            mark[temp]++;
            if (mark[temp] == 1) {
                con++;
            }
        }
        printf("%d\n", con);
    }
    return 0;
}