1-3算法基础-标准模板库STL

1.pair
pair用于存储两个不同类型的值（元素）作为一个单元。它通常用于将两个值捆绑在一起，以便一起传递或返回。

#include <iostream>
#include <utility>
using namespace std;
int main() {
           pair<int, string> person = make_pair(25, "jack");//存储一对值并初始化
//可简写为  pair<int, string> person(25, "jack");
    cout << person.first << " " << person.second;//25 jack
}

嵌套

#include <iostream>
#include <utility>
using namespace std;
int main() {
    pair<int, pair<int, int>> people=make_pair(3, make_pair(4, 5));
    cout << people.second.first;//4
    return 0;
}

排序规则
优先考虑first，若相等再比较second…

#include <iostream>
#include <utility>
#include <algorithm>
using namespace std;
int main() {
    pair<int, std::string> people[] = {
        make_pair(25, "Alice"),
        make_pair(30, "Bob"),
    };
    sort(people, people + 2);
    for (int i = 0; i < 2; i++) {
        cout << people[i].first<< people[i].second << endl;
    }
    return 0;
}

2.vector
提供了动态数组（可变大小数组）的实现，存储的事一系列相同类型的元素

#include <iostream>
#include <vector>
using namespace std;
int main() {
    vector<int> a;//定义整型a容器
    a.push_back(1);
    a.push_back(2);
    a.push_back(3);
    cout << a[0]<<endl;//首元素：1
    a.pop_back();//删除尾部元素
    cout << a.size();//元素个数：2
}

元素插入操作

#include <iostream>
#include <vector>
using namespace std;
int main() {
    vector<int> a = { 5,4,3 };
    a.insert(a.begin() + 1, 999);
    cout << a[1];//999
}

初始化与排序

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
    //初始化
    vector<int> a(5, 1);//对容器a初始化为{1,1,1,1,1}
    vector<int> b = { 5,4,3,2,1 };
    //排序
    sort(b.begin(), b.end());
    for (int i = 0; i < b.size(); i++) {
        cout << b[i];//12345
    }
}

去重排序

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
    vector<int> a = { 5,4,3,2,1,5,5 };
    sort(a.begin(), a.end());
    //unique只能去掉相邻重复元素，所以先sort
    //auto用于自动推导 unique 函数返回的迭代器类型
    auto b = unique(a.begin(), a.end());
    auto n = distance(a.begin(), b);
    for (int i = 0; i < n; i++) {
        cout << a[i];//12345
    }
}

另一种去重排序方式

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
    vector<int> a = { 5,4,3,2,1,5,5 };
    sort(a.begin(), a.end());//1 2 3 4 5 5 5

    auto b = unique(a.begin(), a.end());//b指向了多余元素的起始位置(排序完成后的第二个5的位置)
    a.erase(b, a.end());//擦除从b到末尾的元素，a的大小也同时修改了。即删除了后面的两个5
    for (int i = 0; i < a.size(); i++) {
        cout << a[i];//12345
    }
}

输出可以使用以下方式
循环变量 i 依次取 a 容器中的每个元素的值
const 保证了元素不会被修改
auto 使编译器自动推断元素的类型
& 表示使用引用来避免不必要的复制

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
    vector<int> a = { 5,4,3,2,1,5,5 };
    sort(a.begin(), a.end());
    auto b = unique(a.begin(), a.end());
    a.erase(b, a.end());
    
    for (const auto& i : a) {
        cout << i;//12345
    }
}

3.list
较少使用
以节点存储，以指针链接的链表结构

#include <iostream>
#include <list>
using namespace std;
int main() {
    // 创建一个空的 list，存储整数
    list<int> myList;

    // 在列表末尾插入元素
    myList.push_back(1);
    myList.push_back(2);
    myList.push_back(3);
    //列表元素为123


    // 在列表开头插入元素
    myList.push_front(6);
    //列表元素为6123

    // 遍历列表并打印元素
    for (const auto& i : myList) {
        cout << i << " ";
    }
    cout << endl;
    //输出了：6 1 2 3

    // 删除列表中的元素
    myList.pop_back();
    myList.pop_front();
    //列表元素为12
}

在这里插入图片描述
4.stack

#include <iostream>
#include <stack>
using namespace std;
int main() {
    stack<int> myStack;

    // 压栈操作
    myStack.push(1);
    myStack.push(2);
    myStack.push(3);
    //栈内(从下到上):123

    // 访问栈顶元素
    cout << myStack.top();//3

    // 弹栈操作
    myStack.pop();//3被弹出

    // 再次访问栈顶元素
    cout <<  myStack.top();//2
    //栈内(从下到上):12


    // 获取栈中元素的数量
    cout << "Stack size: " << myStack.size() << endl;//2


    // 检查栈是否为空
    if (myStack.empty()) {
        cout << "Stack is empty." << endl;
    }
    else {
        cout << "Stack is not empty." << endl;
    }
}

在这里插入图片描述
5.queue
（1）普通队列

#include <iostream>
#include <queue>
using namespace std;
int main() {
    queue<int> myQueue;

    // 入队操作
    myQueue.push(1);
    myQueue.push(2);
    myQueue.push(3);
    //队列(从头到尾):123


    // 访问队头元素
    cout << myQueue.front();//1

    // 出队操作
    myQueue.pop();//1出

    // 再次访问队头元素
    cout <<myQueue.front();//2
    //队列(从头到尾):23


    // 获取队列中元素的数量
    cout << myQueue.size();//2

    // 检查队列是否为空
    if (myQueue.empty()) {
        cout << "Queue is empty." << endl;
    }
    else {
        cout << "Queue is not empty." << endl;
    }
}

（2）优先队列/堆
队列中的元素是按照一定优先级进行排序的，默认情况下是从小到大排序的，即最大元素位于队列的前面。在插入元素时会插入到指定位置，确保队内有序。（大根堆）

在这里插入图片描述

#include <iostream>
#include <queue>
using namespace std;
int main() {
    priority_queue<int> maxHeap;

    // 插入元素
    maxHeap.push(3);
    maxHeap.push(1);
    maxHeap.push(4);
    maxHeap.push(2);

    while (!maxHeap.empty()) {
        cout << maxHeap.top()<<" ";
        maxHeap.pop();
    }//4 3 2 1
}

#include <iostream>
#include <queue>
using namespace std;
int main() {
    priority_queue<int> maxHeap;

    // 插入元素
    maxHeap.push(3);
    maxHeap.push(1);
    maxHeap.push(4);
    maxHeap.push(2);
    队列元素:4 3 2 1

    // 访问队头元素（最大元素）
    cout << maxHeap.top();//4

    // 弹出队头元素
    maxHeap.pop();//4出
    //队列元素:3 2 1

    // 再次访问队头元素
    cout << maxHeap.top();//3


    // 获取队列中元素的数量
    cout << maxHeap.size();//3


    // 检查队列是否为空
    if (maxHeap.empty()) {
        cout << "Priority queue is empty." << endl;
    }
    else {
        cout << "Priority queue is not empty." << endl;
    }
}

小根堆

priority_queue<int, vector<int>, greater<int>> minHeap

（3）双端队列
#include <deque>

#include <iostream>
#include <deque>
using namespace std;
int main() {
    // 创建一个双端队列
    deque<int> deque;

    // 向双端队列的尾部添加元素
    deque.push_back(1);//队列元素：1
    deque.push_back(2);//队列元素：1(头) 2(尾)

    // 向双端队列的头部添加元素
    deque.push_front(3);//队列元素：3 1 2
    deque.push_front(4);//队列元素：4 3 1 2

    // 打印双端队列的元素
    for (int n : deque) {
        cout << n;
    }// 4 3 1 2

    // 从双端队列的尾部删除元素
    deque.pop_back();//队列元素：4 3 1

    // 从双端队列的头部删除元素
    deque.pop_front();//队列元素：3 1
}

在这里插入图片描述

[例1] CLZ银行问题
在这里插入图片描述
在这里插入图片描述
评测系统

#include <iostream>
#include <string>
#include <queue>
using namespace std;
int main() {
    int num;
    cin >> num;//操作数量
    queue<string> vipQueue;
    queue<string> normalQueue;
    for (int i = 0; i < num; ++i) {
        string operation,name;
        cin >> operation;
        if (operation == "IN") {
            cin >> name;
            char type;
            cin >> type;
            if (type == 'V') {
                vipQueue.push(name);
            }
            else {
                normalQueue.push(name);
            }
        }
        else {
            char type;
            cin >> type;
            if (type == 'V'&&!vipQueue.empty()) {
                vipQueue.pop();
            }
            else if(type=='N'&&!normalQueue.empty()) {
                normalQueue.pop();
            }
        }
    }
    while (!vipQueue.empty()) {
        cout << vipQueue.front()<<endl;
        vipQueue.pop();
    }
    while (!normalQueue.empty()) {
        cout << normalQueue.front() << endl;
        normalQueue.pop();
    }
}

[例2] 合并果子
在这里插入图片描述
在这里插入图片描述
评测系统

每次选择两个最小的数合并（贪心），并将合并后的新数重新放入堆中

#include <iostream>
#include <string>
#include <queue>
using namespace std;
int main() {
    int kind;
    cin >> kind;
    priority_queue<int, vector<int>, greater<int>> minHeap;
    for (int i = 0; i < kind; ++i) {
        int num;
        cin >> num;
        minHeap.push(num);
    }
    int sum = 0;
    while (minHeap.size() > 1) {
        int heapone=minHeap.top();
        minHeap.pop();
        int heaptwo = minHeap.top();
        minHeap.pop();
        sum += heapone + heaptwo;
        minHeap.push(heapone + heaptwo);
    }
    cout << sum;
}

[例3] 建筑抢修
在这里插入图片描述
在这里插入图片描述

评测系统

我们对建筑按照截止时间进行排序，并使用一个最大堆（优先队列）来动态管理当前的修理计划。每次当总修理时间超过当前考虑的建筑的截止时间时，我们从堆中移除修理时间最长的建筑。

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
struct building {
    int repairtime;
    int deadline;
};
int cmp(building a, building b) {
    return a.deadline < b.deadline;
}
int main()
{
    int total = 0;
    int n;
    cin >> n;
    vector<building> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i].repairtime >> a[i].deadline;
    }
    sort(a.begin(), a.end(), cmp);
    priority_queue<int> q;
    for (int i = 0; i < n; i++) {
        q.push(a[i].repairtime);//一定修，因为马上deadline了
        total += a[i].repairtime;
        if (total > a[i].deadline) {//如果超时，那么根据大根堆，队列中维修时长最大的移除
            total -= q.top();
            q.pop();
        }
    }
    cout << q.size();
    return 0;
}

6.set
set存储唯一元素，默认升序

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

int main() {
    set<int> s;
    s.insert(3);
    s.insert(1);
    s.insert(4);
    s.insert(2);
    s.insert(2); // 这个操作没有效果，因为 2 已存在

    cout << "Set contains:";
    for (int x : s) {
        cout << " " << x;
    }
    cout << endl;
    //输出：1 2 3 4
}

降序排列

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

int main() {
    set<int,greater<int>> s;//改为降序排列
    s.insert(3);
    s.insert(1);
    s.insert(4);
    s.insert(2);
    s.insert(2);

    cout << "Set contains:";
    for (int x : s) {
        cout << " " << x;
    }
    cout << endl;
    //输出：4 3 2 1
}

在这里插入图片描述
在这里插入图片描述

multiset允许重复元素

#include <iostream>
#include <set>

using namespace std;

int main() {
    multiset<int> ms;

    ms.insert(3);
    ms.insert(1);
    ms.insert(4);
    ms.insert(2);
    ms.insert(2);  // 可以插入重复元素

    // 输出 multiset 的内容
    cout << "Multiset contains:";
    for (int x : ms) {
        cout << " " << x;
    }
    //输出：1 2 2 3 4

    // 计算某个值在 multiset 中出现的次数
    int count = ms.count(2);
    cout <<count;//2
}

在这里插入图片描述
在这里插入图片描述

7.map
map存储键值对，键是唯一的，键值对是根据键排序的（自动排序，默认升序排列），可以直接使用键访问对应的值；在插入新元素时，若键已存在，则更新其对应的值

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

int main() {
    // 创建一个 map
    map<string, int> marks;

    // 插入键值对
    marks["Alice"] = 88;
    marks["Bob"] = 95;
    marks["Charlie"] = 72;

    // 更新键对应的值
    marks["Alice"] = 91;

    // 遍历并打印 map
    for (const auto& pair : marks) {
        cout << pair.first << pair.second << endl;
    }
    /*输出
    Alice91
    Bob95
    Charlie72
    */


    // 查找并访问元素
    if (marks.find("Bob") != marks.end()) {
        cout << marks["Bob"];//95
    }
}

在这里插入图片描述
8.练习
（1）宝藏排序
在这里插入图片描述
评测系统

#include <iostream>
#include<queue>
using namespace std;
int main() {
    int n;
    cin >> n;
    priority_queue<int,vector<int>,greater<int>> pq;
    while (n--) {
        int x;
        cin >> x;
        pq.push(x);
    }
    while(!pq.empty()) {
        cout<<pq.top()<<" ";
        pq.pop();
    }
}

（2）小蓝吃糖果
在这里插入图片描述
评测系统

找出糖果数量最多的种类，其余糖果进行插空。
若最多种类的糖果数量是max，一共有max-1个空，第二大种类的糖果数一定不超过max-1，越插空越多，以此类推。只有当所有糖果加起来也没有填满max-1个空时，失败。

#include <iostream>
#include <queue>
using namespace std;
int main() {
    int n;
    cin >> n;
    long long int total=0;
    priority_queue<int> a;
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        a.push(x);
        total += x;
    }
    int max = a.top();
    total -= max;
    if (max - 1 <= total)
        cout << "Yes";
    else
        cout << "No";
}

（3）小蓝的括号串
在这里插入图片描述
在这里插入图片描述
评测系统

#include <iostream>
#include <stack>
using namespace std;
int main() {
    stack<char> s;
    int n;
    cin >> n;
    while (n--) {
        char x;
        cin >> x;
        if (x == '(') {
            s.push(x);
        }
        else {
            if (!s.empty()) {
                s.pop();
            }
            else {
                cout << "No";
                return 0;
            }
        }
    }
    if (!s.empty()) {
        cout << "No";
    }
    else {
        cout << "Yes";
    }
}

（4）快递分拣
在这里插入图片描述
在这里插入图片描述
评测系统

#include <iostream>
#include <map>
#include <vector>
using namespace std;
int main() {
	int n;
	cin >> n;
	map<string, vector<string>> m;//一对多的关系，一个键对应多个值
	vector<string> vm;//记录城市出现顺序
	while (n--) {
		string s, p;
		cin >> s >> p;
		if (m.find(p) == m.end()) {//当前城市首次出现，可改为if(m.count(p)==0)
			vm.push_back(p);
		}
		m[p].push_back(s);
	}
	for (const auto& x : vm) {
		cout << x <<" " << m[x].size() << endl;
		for (const auto& x2 : m[x]) {
			cout << x2 << endl;
		}
	}
}

（5）顺子日期
在这里插入图片描述
答案：14

#include<iostream>
#include<string>
using namespace std;
int panduanmonth(int x) {
	if (x == 1 || x == 3 || x == 5 || x == 7 || x == 8 || x == 10 || x == 12)
		return 31;
	else if (x == 4 || x == 6 || x == 9 || x == 11)
		return 30;
	else {
		return 28;
	}
}
string formatDate(int a, int b, int c) {
	string s = "2022";
	if (b < 10) {
		s+= "0"+to_string(b);
	}
	else {
		s+= to_string(b);
	}
	if (c < 10) {
		s += "0" + to_string(c);
	}
	else {
		s += to_string(c);
	}
	return s;
}
bool isSequentialDate(string s) {
	for (int i = 0; i <= 5; ++i) {
		if (s[i] + 1 == s[i + 1] && s[i + 1] + 1 == s[i + 2])
			return true;
	}
	return false;
}
int main() {
	int count = 0;
	for (int month = 1; month <= 12; month++) {
		for (int day = 1; day <= panduanmonth(month); day++) {
			string date = formatDate(2022, month, day);
			if (isSequentialDate(date)) {
				count++;
			}
		}
	}
	cout << count;
}

（6）小明和完美序列
在这里插入图片描述
评测系统
对于序列中的每个数字，计算它出现的次数。比较其值和出现的次数。如果出现次数大于数字的值，则需要删除多余的出现。如果出现次数小于数字的值，则需要全部删除。计算总共需要删除的数字数量。

#include<iostream>
#include<vector>
#include<map>
using namespace std;
int main() {
	int n;
	cin >> n;
	map<int, int> count;
	int num;
	for (int i = 0; i < n; ++i) {
		cin >> num;
		count[num]++;
	}
	int deletecount = 0;
	for (const auto& x : count) {
		int a = x.first;
		int b = x.second;
		if (a > b) {
			deletecount += b;
		}
		else if (a < b) {
			deletecount += b - a;
		}
	}
	cout << deletecount;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/243676.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

速卖通（AliExpress）店铺流量怎么转化？自养号测评策略

速卖通（AliExpress）店铺流量怎么转化？自养号测评策略

随着全球电商的蓬勃发展&#xff0c;速卖通&#xff08;AliExpress&#xff09;作为中国领先的跨境电商平台&#xff0c;为卖家提供了一个广阔的销售舞台。然而&#xff0c;对于卖家来说&#xff0c;如何让速卖通店铺实现转化&#xff0c;吸引更多的买家成为关键。 一、速卖通…
阅读更多...
PADS的使用

PADS的使用

目录 一、PADS常规操作1.1 常用快捷键1.2 Logic相关设置 二、Logic库操作2.1 逻辑库2.2 封装库2.3 元件库 一、PADS常规操作 PADS安装好了之后&#xff0c;主要使用下面三个软件&#xff1a; Logic&#xff1a;画原理图文件&#xff0c;也可以使用OrCAD导入Router&#xff1a;…
阅读更多...
分类预测 | Matlab实现DBO-SVM蜣螂算法优化支持向量机的数据分类预测【23年新算法】

分类预测 | Matlab实现DBO-SVM蜣螂算法优化支持向量机的数据分类预测【23年新算法】

分类预测 | Matlab实现DBO-SVM蜣螂算法优化支持向量机的数据分类预测【23年新算法】 目录 分类预测 | Matlab实现DBO-SVM蜣螂算法优化支持向量机的数据分类预测【23年新算法】分类效果基本描述程序设计参考资料 分类效果 基本描述 1.Matlab实现DBO-SVM蜣螂算法优化支持向量机的…
阅读更多...
让测试效率起飞的8款浏览器兼容性测试工具，你get了吗？

让测试效率起飞的8款浏览器兼容性测试工具，你get了吗？

浏览器的兼容性问题&#xff0c;是指不同浏览器使用内核及所支持的 HTML 等网页语言标准不同&#xff0c;用户客户端的环境不同造成的显示效果不能达到理想效果。 对于用户而言&#xff0c;无论使用哪款浏览器&#xff0c;期望看到的效果是正常的统一的。市面上发布的浏览器版…
阅读更多...
什么是代码签名证书

什么是代码签名证书

代码签名证书是一种用于验证软件开发者身份并确保软件完整性的数字证书。在如今数字化的世界中&#xff0c;代码签名证书扮演着至关重要的角色。它们不仅为软件开发者提供了一种方式来证明其身份&#xff0c;还有助于保护用户免受恶意软件和未经授权的软件更改的侵害。 首先&am…
阅读更多...
maui 调用文心一言开发的聊天APP 3

maui 调用文心一言开发的聊天APP 3

主要是对代码进行了优化 上一个版本写死了帐号跟密码 &#xff0c;这一个帐本有户可以直接设置对相关的key以及secret如果设置错时&#xff0c;在聊天中也会返回提示。注册帐号时同时也设置了key及secrete升级到了net.8.0导出APK&#xff0c;上一个版本是导出abb.解决了变型问…
阅读更多...
动物姿态估计：微调 YOLOv8 姿态模型

动物姿态估计：微调 YOLOv8 姿态模型

动物姿态估计是计算机视觉的一个研究领域&#xff0c;是人工智能的一个子领域&#xff0c;专注于自动检测和分析图像或视频片段中动物的姿势和位置。目标是确定一种或多种动物的身体部位&#xff08;例如头部、四肢和尾巴&#xff09;的空间排列。这项技术具有广泛的应用&#…
阅读更多...
一起学习生成式人工智能（四）｜用低代码实现人工智能应用

一起学习生成式人工智能（四）｜用低代码实现人工智能应用

点击蓝字 关注我们 编辑&#xff1a;Alan Wang 排版&#xff1a;Rani Sun 微软 Reactor 为帮助广开发者&#xff0c;技术爱好者&#xff0c;更好的学习 .NET Core, C#, Python&#xff0c;数据科学&#xff0c;机器学习&#xff0c;AI&#xff0c;区块链, IoT 等技术&#xff0…
阅读更多...
EasyRecovery(数据恢复软件) 2024中文绿色无需激活版下载

EasyRecovery(数据恢复软件) 2024中文绿色无需激活版下载

EasyRecovery是一款功能强大且专业的数据恢复软件&#xff0c;软件能够对电脑误删的文件进行恢复&#xff0c;包括格式化硬盘是数据恢复、手机U盘数据恢复等&#xff0c;小编今天给大家带来的是根据官软件解压后直接使用。感兴趣的朋友快来下载使用吧。 EasyRecovery-2024mac最…
阅读更多...
Java数据结构篇——实现顺序表的增删查改

Java数据结构篇——实现顺序表的增删查改

文章目录 1.线性表2. 顺序表2.1 顺序表结构2.2 实现顺序表接口2.3 打印顺序表2.2 实现新增元素2.3 实现查找元素2.3 获取pos位置的值2.4 删除元素2.5 获取顺序表的长度2.6 清空顺序表 3.代码在这 1.线性表 定义&#xff1a;线性表是 n 个具有相同特性的数据元素的有序序列。线…
阅读更多...
数据库性能优化八大方案

数据库性能优化八大方案

毫不夸张的说咱们后端工程师&#xff0c;无论在哪家公司&#xff0c;呆在哪个团队&#xff0c;做哪个系统&#xff0c;遇到的第一个让人头疼的问题绝对是数据库性能问题。如果我们有一套成熟的方法论&#xff0c;能让大家快速、准确的去选择出合适的优化方案&#xff0c;我相信…
阅读更多...
Unity之OpenXR+XR Interaction Toolkit接入Meta Quest3

Unity之OpenXR+XR Interaction Toolkit接入Meta Quest3

前言 随着备受期待的Meta Quest 3与今年10月10日发布，这款来自Meta的下一代VR游戏头戴设备承诺将彻底改变您的游戏方式。 Meta Quest 3，玩家只需轻松一触即可在虚拟现实和真实世界之间无缝切换，无需摘下头戴设备进行快速现实检查。 Meta Quest 3最引人注目的特点之一是其能…
阅读更多...
【知识积累】深度度量学习综述

【知识积累】深度度量学习综述

原文指路&#xff1a;https://hav4ik.github.io/articles/deep-metric-learning-survey Problem Setting of Supervised Metric Learning 深度度量学习是一组旨在衡量数据样本之间相似性的技术。 Contrastive Approaches 对比方法的主要思想是设计一个损失函数&#xff0c;直…
阅读更多...
pytorch中的归一化：BatchNorm、LayerNorm 和 GroupNorm

pytorch中的归一化：BatchNorm、LayerNorm 和 GroupNorm

1 归一化概述 训练深度神经网络是一项具有挑战性的任务。 多年来&#xff0c;研究人员提出了不同的方法来加速和稳定学习过程。 归一化是一种被证明在这方面非常有效的技术。 1.1 为什么要归一化 数据的归一化操作是数据处理的一项基础性工作&#xff0c;在一些实际问题中&am…
阅读更多...
六.聚合函数

六.聚合函数

聚合函数 1.什么是聚合函数1.1AVG和SUM函数1.2MIN和MAX函数1.3COUNT函数 2.GROUP BY2.1基本使用2.2使用多个列分组2.3GROUP BY中使用WITH ROLLUP 3.HAVING3.1基本使用3.2WHERE和HAVING的区别 4.SELECT的执行过程4.1查询的结构4.2SELECT执行顺序4.3SQL执行原理 1.什么是聚合函数…
阅读更多...
JOSEF约瑟快速跳闸继电器RXMS1RK216063 DC220V

JOSEF约瑟快速跳闸继电器RXMS1RK216063 DC220V

系列型号 RXMS1 RK 216 437快速跳闸继电器&#xff1b;RXMS1 RK 216 237快速跳闸继电器&#xff1b; RXMS1 RK 216 449快速跳闸继电器&#xff1b;RXMS1 RK 216 249快速跳闸继电器&#xff1b; RXMS1 RK 216 450快速跳闸继电器&#xff1b;RXMS1 RK 216 250快速跳闸继电器&a…
阅读更多...
HarmonyOS使用Web组件

HarmonyOS使用Web组件

Web组件的使用 1 概述 相信大家都遇到过这样的场景&#xff0c;有时候我们点击应用的页面&#xff0c;会跳转到一个类似浏览器加载的页面&#xff0c;加载完成后&#xff0c;才显示这个页面的具体内容&#xff0c;这个加载和显示网页的过程通常都是浏览器的任务。 ArkUI为我…
阅读更多...
C语言实现贪吃蛇【完整版】

C语言实现贪吃蛇【完整版】

贪吃蛇 文章目录 贪吃蛇使用到的WIN32一些接口简单介绍控制台窗口大小隐藏光标控制光标的位置获取键盘的值的情况字符问题 游戏逻辑开始游戏打印地图初始化贪吃蛇创建食物 运行游戏控制蛇的移动 运行结束 贪吃蛇实现出来的效果如下&#xff1a; 贪吃蛇小游戏录屏 完整代码&…
阅读更多...
【Spark精讲】Spark存储原理

【Spark精讲】Spark存储原理

目录 类比HDFS的存储架构 Spark的存储架构 存储级别 RDD的持久化机制 RDD缓存的过程 Block淘汰和落盘 类比HDFS的存储架构 HDFS集群有两类节点以管理节点-工作节点模式运行&#xff0c;即一个NameNode(管理节点)和多个DataNode(工作节点)。 Namenode管理文件系统的命名空…
阅读更多...
销售技巧培训之如何提升金融销售技巧

销售技巧培训之如何提升金融销售技巧

销售技巧培训之如何提升金融销售技巧 在金融行业&#xff0c;销售技巧是决定业绩成败的关键因素之一。无论是销售保险、股票、债券&#xff0c;还是提供投资咨询服务&#xff0c;都需要掌握一定的销售技巧。本文将探讨如何提升金融销售技巧&#xff0c;通过案例分析&#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023