C++系列-STL容器之deque

news2024/11/15 11:52:34

STL容器之deque

  • deque概括
    • deque与vector内存管理的区别
      • vector内存分配方式
      • deque内存分配方式
    • deque与vector随机访问效率的区别
    • deque与vector插入和删除操作的区别
    • deque与vector适用场景
  • deque的构造函数
    • deque的构造函数举例
  • deque的赋值操作
  • deque容器的大小操作
  • deque容器的插入和删除
    • 两端插入和删除
    • 指定位置
    • 删除操作
  • deque容器的数据存取
  • deque容器排序

deque概括

  • deque是一种序列容器。
  • deque维护双端数组，头尾都可以直接插入和删除操作。
    在这里插入图片描述

deque与vector内存管理的区别

vector内存分配方式

vector采用连续的线性内存空间，当需要增加容量时，通常会重新分配一块更大的连续内存空间，并将原有元素复制到新空间，然后释放旧空间。这可能会导致较高的时间开销，特别是当容器中元素数量较大时。

deque内存分配方式

  • deque有一系列固定大小的块组成，这些块可以在不连续的内存空间中，deque这些固定大小的块称为缓冲区。
  • 在两端进行插入或删除操作时，deque可以更高效的管理内存，不像vector那样进行大量的元素移动。
  • 为了有效的管理这些缓冲区，deque使用中控器(通常是指针数组)的结构，中控器记录每个缓冲器的地址和大小，以及deque的当前size和capacity。
  • 当在deque的两端插入操作时，如果当前的存储块还有足够的空间，新元素就会被插入到相应的空间，否则，deque会分配一个新的缓冲区，并将其添加到合适的位置。
  • 当deque在中间进行插入或删除操作时，deuqe调整涉及到的缓冲区中的元素，并可能需要重新分配或释放一些存储块。
    在这里插入图片描述

deque与vector随机访问效率的区别

  • vector支持高效的随机访问。
  • 也支持随机访问，但是由于其内部结构的复杂性，随机访问的效率略低于vector。

deque与vector插入和删除操作的区别

  • vector在尾部插入和删除操作通常是高效的。但在头部或中部插入和删除操作需要移动大量元素。
  • 在两端插入和删除数据都非常高效。在中间插入和删除的效率相对较低，但是比vertor在中间进行插入和删除的操作要快。

deque与vector适用场景

  • vector适用于需要高效的随机访问和在尾部进行频繁插入和删除的场景。例如，存储一组整数并进行频繁的遍历和在尾部添加元素。
  • deque适用于在两端进行高效插入和删除的场景，例如，实现一个队列或栈结构。或者在容器的两端进行频繁的插入和删除操作。

deque的构造函数

  • 默认构造函数，创建一个新的deque。
deque<T> d1;
  • 拷贝构造函数，从一个deque对象创建一个副本。
deque<T> d2(const vector<T> &d1);
  • 使用迭代器范围构造函数，从两个迭代器指定的范围创建deque。
deque<T> d2(obj.begin(), obj.end());
  • 将n个elem拷贝给deque
deque<T> d1(n, elem);

deque的构造函数举例

code:
#include <iostream>
#include <deque>
using namespace std;

void print_deque(const deque<int>& deq)		// 如果这里传参为const &，下面的迭代器也要用const_iterator
{
	for (deque<int>::const_iterator it = deq.begin(); it < deq.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	int num = 0;
	deque<int> d1;			// 默认构造函数
	d1.push_front(11);
	d1.push_front(22);
	d1.push_front(33);
	cout << "---------- 默认构造函数举例 ----------" << endl;
	print_deque(d1);
	
	d1.push_back(666);
	deque<int> d2(d1);			// 拷贝构造函数
	cout << "---------- 拷贝构造函数举例 ----------" << endl;
	print_deque(d2);

	deque<int>d3(10, 888);		// n个elem初始化举例
	cout << "---------- n个elem初始化构造函数举例 ----------" << endl;
	print_deque(d3);

	deque<int>d4{1, 2, 3, 4, 5, 6, 7, 8, 9};	// 花括号初始化
	cout << "---------- 花括号初始化构造函数举例 ----------" << endl;
	print_deque(d4);

	deque<int>d5(d4.begin(), d4.end()-3);
	cout << "---------- 迭代器范围初始化构造函数举例 ----------" << endl;
	print_deque(d5);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

result:
---------- 默认构造函数举例 ----------
33 22 11
---------- 拷贝构造函数举例 ----------
33 22 11 666
---------- n个elem初始化构造函数举例 ----------
888 888 888 888 888 888 888 888 888 888
---------- 花括号初始化构造函数举例 ----------
1 2 3 4 5 6 7 8 9
---------- 迭代器范围初始化构造函数举例 ----------
1 2 3 4 5 6

deque的赋值操作

  • = 赋值，函数原型 deque& operator=(const deque&vec), 重载等号运算符。
  • deq1.assign(beg迭代器，end迭代器), 将[beg迭代器，end迭代器) 之间的数据拷贝给被赋值的对象。
  • deq1.assign(n，elem), 将n个elem的数据拷贝给被赋值的对象。
code:
#include <iostream>
#include <deque>
using namespace std;

void print_deque(const deque<int>& deq)		// 如果这里传参为const &，下面的迭代器也要用const_iterator
{
	for (deque<int>::const_iterator it = deq.begin(); it < deq.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	int num = 0;
	deque<int> d1;			// 默认构造函数
	d1.push_front(11);
	d1.push_front(22);
	d1.push_front(33);

	cout << "---------- =赋值 ----------" << endl;
	deque<int> d2 = d1;
	print_deque(d2);

	deque<int> d3;
	cout << "---------- deq.assign(n, elem)赋值 ----------" << endl;
	d3.assign(5, 555);
	print_deque(d3);

	deque<int> d4;
	d3.push_back(666);
	cout << "---------- deq.assign(deq)赋值 ----------" << endl;
	d4.assign(d3.begin(), d3.end());
	print_deque(d4);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

result:
---------- =赋值 ----------
33 22 11
---------- deq.assign(n, elem)赋值 ----------
555 555 555 555 555
---------- deq.assign(deq)赋值 ----------
555 555 555 555 555 666

deque容器的大小操作

  • 没有capacity，因为它的容量是动态的，随时扩展。
    | 函数原型 | 用途 |
    |:--------😐 :-------------|
    |empty()| 判断容器是否为空|
    |size() | 返回容器中元素的个数|
    |resize(int num) | 重新指定容器的长度(size)为num，若容器变长，则以默认数值填充新位置，如果容器变短，则末尾超出容器长度的元素被删除|
    |resize(int num，elem) | 重新指定容器的长度(size)为num，若容器变长，则以elem填充新位置，如果容器变短，则末尾超出容器长度的元素被删除|
code:

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

void print_deque(const deque<int>& deq)		// 如果这里传参为const &，下面的迭代器也要用const_iterator
{
	for (deque<int>::const_iterator it = deq.begin(); it < deq.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	int num = 0;
	deque<int> d1;
	d1.push_front(11);
	d1.push_front(22);
	d1.push_front(33);
	deque<int> d2;

	if (!d1.empty())
	{
		cout << "d1 is not empty" << endl;
		cout << "d1 size: " << d1.size() << endl;
	}
	if (d2.empty())		// 判断容器是否为空
	{
		cout << "d2 is empty" << endl;
	}

	deque<int> d3 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};	// 花括号初始化
	cout << "---------- d3 ----------" << endl;
	print_deque(d3);
	cout << "d3 size: " << d3.size() << endl;

	d3.resize(12);		// resize，默认填充0
	cout << "---------- d3.resize(12) ----------" << endl;
	print_deque(d3);
	cout << "d3 size: " << d3.size() << endl;

	d3.resize(15, 666);	// resize，填充指定数据
	cout << "---------- d3.resize(15, 666) ----------" << endl;
	print_deque(d3);
	cout << "d3 size: " << d3.size() << endl;

	d3.resize(5);		// resize，长度截短
	cout << "---------- d3.resize(5) ----------" << endl;
	print_deque(d3);
	cout << "d3 size: " << d3.size() << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

result:
d1 is not empty
d1 size: 3
d2 is empty
---------- d3 ----------
0 1 2 3 4 5 6 7 8 9
d3 size: 10
---------- d3.resize(12) ----------
0 1 2 3 4 5 6 7 8 9 0 0
d3 size: 12
---------- d3.resize(15, 666) ----------
0 1 2 3 4 5 6 7 8 9 0 0 666 666 666
d3 size: 15
---------- d3.resize(5) ----------
0 1 2 3 4
d3 size: 5

deque容器的插入和删除

两端插入和删除

函数原型用途
push_back(elem)尾部插入元素elem
push_front(elem)头部插入元素elem
pop_back()删除尾部元素
pop_front(elem)删除头部元素
code:
#include <iostream>
#include <deque>
using namespace std;

void print_deque(const deque<int>& deq)		// 如果这里传参为const &，下面的迭代器也要用const_iterator
{
	for (deque<int>::const_iterator it = deq.begin(); it < deq.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	int num = 0;
	deque<int> d1{0,1,2,3,4,5};
	d1.push_front(111);
	d1.push_back(222);
	cout << "---------- push front and push back ----------" << endl;
	print_deque(d1);

	d1.pop_back();
	cout << "---------- d1.pop_back() ----------" << endl;
	print_deque(d1);

	d1.pop_front();
	cout << "---------- d1.pop_front() ----------" << endl;
	print_deque(d1);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

result:
---------- push front and push back ----------
111 0 1 2 3 4 5 222
---------- pop_back ----------
111 0 1 2 3 4 5
---------- pop_front ----------
0 1 2 3 4 5

指定位置

函数原型用途
insert(const_iterator pos, elem)迭代器指向位置pos插入元素elem，返回新数据的位置，iterator类型
insert(const_iterator pos, int count, elem)迭代器指向位置pos插入count元素elem，返回的是插入的最后一个元素的位置，iterator类型
insert(const_iterator pos, iterator pos begin, iterator pos end)迭代器指向位置pos插入迭代器begin到迭代器end范围内的数据，返回插入的最后一个元素的位置，iterator
erase(const_iterator pos)删除迭代器指向的元素，返回下一个元素的位置
erase(const_iterator start, const_iterator end)删除迭代器从[start, end)之间的元素，包头不包尾，返回下一个元素的位置
clear()删除容器中所有元素，返回下一个元素的位置

关于insert的例子

code:
#include <iostream>
#include <deque>
using namespace std;

void print_deque(const deque<int>& deq)		// 如果这里传参为const &，下面的迭代器也要用const_iterator
{
	for (deque<int>::const_iterator it = deq.begin(); it < deq.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	int num = 0;
	deque<int> d1{0,1,2,3,4,5};
	cout << "---------- d1 ----------" << endl;
	print_deque(d1);

	// insert(const_iterator pos, elem)
	deque<int>::iterator it = d1.insert(d1.begin(), 111);	// 返回插入的数据对应的位置
	cout << "---------- d1.insert(d1.begin(), 111) ----------" << endl;
	print_deque(d1);
	cout << "d1.insert(d1.begin(), 111)返回的iter指示的内容: " << * it << endl;
	
	// insert(const_iterator pos, int count, elem)
	it = d1.insert(d1.begin(), 3, 333);		// 在pos处插入count个elem
	cout << "---------- d1.insert(d1.begin(), 3, 333) ----------" << endl;
	print_deque(d1);
	cout << "*it(it是d1.insert(d1.begin(), 3, 333)的返回值): " << *it << endl;
	
	// 判断返回值指向的位置
	d1.insert(it, 666);
	cout << "---------- d1.insert(it, 666)，it是d1.insert(d1.begin(), 3, 333)的返回值 ----------" << endl;
	print_deque(d1);

	// insert(const_iterator pos, iterator pos begin, iterator pos end)
	deque<int> d2 {11, 22, 33};
	cout << "---------- d2 ----------" << endl;
	print_deque(d2);
	it = d2.insert(d2.begin(), d1.begin()+6, d1.end());
	cout << "---------- d2.insert(d2.begin(), d1.begin()+6, d1.end()) ----------" << endl;
	print_deque(d2);
	cout << "*it(it是d2.insert(d2.begin(), d1.begin()+6, d1.end()): " << *it << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

result:
---------- d1 ----------
0 1 2 3 4 5
---------- d1.insert(d1.begin(), 111) ----------
111 0 1 2 3 4 5
d1.insert(d1.begin(), 111)返回的iter指示的内容: 111
---------- d1.insert(d1.begin(), 3, 333) ----------
333 333 333 111 0 1 2 3 4 5
*it(it是d1.insert(d1.begin(), 3, 333)的返回值): 333
---------- d1.insert(it, 666)，it是d1.insert(d1.begin(), 3, 333)的返回值 ----------
666 333 333 333 111 0 1 2 3 4 5
---------- d2 ----------
11 22 33
---------- d2.insert(d2.begin(), d1.begin()+6, d1.end()) ----------
1 2 3 4 5 11 22 33
*it(it是d2.insert(d2.begin(), d1.begin()+6, d1.end()): 1

删除操作

code:
#include <iostream>
#include <deque>
using namespace std;

void print_deque(const deque<int>& deq)		// 如果这里传参为const &，下面的迭代器也要用const_iterator
{
	for (deque<int>::const_iterator it = deq.begin(); it < deq.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	int num = 0;
	deque<int> d1{0, 1, 2, 3, 4, 5};
	cout << "---------- d1 ----------" << endl;
	print_deque(d1);

	deque<int>::iterator it = d1.erase(d1.begin() + 2);		// 删除d1.begin()+2处的元素，it返回begin()+3处的元素
	cout << "---------- d1.erase(it)(it = d1.begin() + 2) ----------" << endl;
	print_deque(d1);
	cout << "*it(d1.erase(d1.begin() + 2)的返回值): " << *it << endl;

	it = d1.erase(d1.begin(), d1.begin() + 2);		// 删除[d1.begin(), d1.begin() + 2)前闭后开区间的元素，it返回begin()+2处的元素
	cout << "---------- d1.erase(d1.begin(), d1.begin() + 2) ----------" << endl;
	print_deque(d1);
	cout << "*it(it是d1.erase(d1.begin(), d1.begin() + 2)的返回值): " << *it << endl;

	d1.clear();
	cout << "---------- d1.clear() ----------" << endl;
	print_deque(d1);	
	cout << "d1 size: " << d1.size() << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

result:
---------- d1 ----------
0 1 2 3 4 5
---------- d1.erase(it)(it = d1.begin() + 2) ----------
0 1 3 4 5
*it(d1.erase(d1.begin() + 2)的返回值): 3
---------- d1.erase(d1.begin(), d1.begin() + 2) ----------
3 4 5
*it(it是d1.erase(d1.begin(), d1.begin() + 2)的返回值): 3
---------- d1.clear() ----------

d1 size: 0

deque容器的数据存取

函数原型用途
deq.at(int idx)返回索引idx所指的元素
deq[idx]返回索引idx所指的元素
deq.front()返回容器中的第一个元素
deq.back()返回容器中的最后一个元素
code:
#include <iostream>
#include <deque>
using namespace std;

void print_square(const deque<int> &deq)
{
	for (int i_loop = 0; i_loop < deq.size(); i_loop++)
	{
		cout << deq[i_loop] << " ";
	}
	cout << endl;
}

void print_at(const deque<int>& deq)
{
	for (int i_loop = 0; i_loop < deq.size(); i_loop++)
	{
		cout << deq.at(i_loop) << " ";
	}
	cout << endl;
}

void test01()
{
	int num = 0;
	deque<int> d1{0, 1, 2, 3, 4, 5};
	cout << "---------- print_square ----------" << endl;
	print_square(d1);
	cout << "---------- print_at ----------" << endl;
	print_at(d1);
	cout << "---------- deq.front() ----------" << endl;
	cout << d1.front() << endl;
	cout << "---------- deq.back() ----------" << endl;
	cout << d1.back() << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

result:
---------- print_square ----------
0 1 2 3 4 5
---------- print_at ----------
0 1 2 3 4 5
---------- deq.front() ----------
0
---------- deq.back() ----------
5

deque容器排序

  • sort(iterator begin, iterator end)可以对容器进行排序。
  • 默认升序排序，支持随机访问的迭代器的容器，都可用sort排序。
  • 要#include 
code:
#include <iostream>
#include <deque>
#include <algorithm>
using namespace std;

void print_deque(const deque<int>& deq)
{
	for (deque<int>::const_iterator it = deq.begin(); it < deq.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	int num = 0;
	deque<int> d1{10, 55, 24, 79, 36, 5};
	cout << "---------- d1 ----------" << endl;
	print_deque(d1);
	
	cout << "---------- sort(d1.begin(), d1.end()) ----------" << endl;
	sort(d1.begin(), d1.end());		// d1会被排序，默认升序排序，支持随机访问的迭代器的容器，都可用sort排序
	print_deque(d1);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

result:
---------- d1 ----------
10 55 24 79 36 5
---------- sort(d1.begin(), d1.end()) ----------
5 10 24 36 55 79

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

瑞芯微RK3566开发板USB OTG模式介绍及命令切换，触觉智能EVB3566主板鸿蒙硬件厂商

瑞芯微RK3566开发板USB OTG模式介绍及命令切换，触觉智能EVB3566主板鸿蒙硬件厂商

一、USB OTG的模式 host模式&#xff08;下行&#xff09;&#xff1a;为u盘等设备供电&#xff0c;不可以进行调试&#xff0c;连接adb或者烧录等操作。 device模式&#xff08;上行&#xff09;&#xff1a;可以进行调试&#xff0c;连接adb或者烧录等操作&#xff0c;即US…
阅读更多...
Delphi5实现主要——明细型数据库应用

Delphi5实现主要——明细型数据库应用

文章目录 效果图主要——明细型数据库特点 数据库实现方式完整代码 效果图 主要——明细型数据库 在Delphi中&#xff0c;主要——明细型数据库是一种数据库应用程序的设计模式&#xff0c;它涉及到多个数据库表之间的关联操作&#xff0c;以实现对复杂数据结构的有效管理。这…
阅读更多...
数据结构（邓俊辉）学习笔记】串 16——Karp-Rabin算法：串即是数

数据结构（邓俊辉）学习笔记】串 16——Karp-Rabin算法：串即是数

文章目录 1. 化串为数2. 凡物皆数3. 亦是数 1. 化串为数 接下来的这节&#xff0c;我们再来讨论一种十分另类的串匹配算法&#xff0c;也就是所谓的 Karp-Rabin 算法。回顾此前所介绍的几种串匹配算法&#xff0c;我们所面临的难题是一样的。也就是说在这里&#xff0c;我们每次…
阅读更多...
ES配合高德地图JS-API实现地理位置查询

ES配合高德地图JS-API实现地理位置查询

目录 实现功能点 技术选型 具体实现 Vue3整合高德地图JS API-2.0 添加商户&#xff1a;前端 添加商户&#xff1a;后端/ES 查询用户当前地理坐标 获取附近&#xff08;指定距离&#xff09;的商户 总结/测试Demo代码地址 测试概述&#xff1a;用户使用高德地图组件获取商户…
阅读更多...
GPT实现的adb shell命令实现某音自动点赞和关注

GPT实现的adb shell命令实现某音自动点赞和关注

摘要：这个可能是没啥用的自动点赞和关注功能，自娱自乐为主哈 具体可行性步骤如下： 1.打开手机的开发者选项，将指针位置的设置开关打开，目的是看触屏时的坐标值 2.随便打开一个抖音，找到点赞的爱心图标的坐标轴，并记下来，待会有用 备注：尽量获取爱心尖端的坐标值，由…
阅读更多...
erlang学习：用OTP构建系统2，警报管理

erlang学习：用OTP构建系统2，警报管理

今日学习用OTP构建系统的警报管理&#xff0c; 首先进行配置错误记录器 [{sasl,[{sasl_error_logger, false},{error_logger_mf_dir, "/code/erlang/erlangstudy"},{error_logger_mf_maxbytes, 10485760},{error_logger_mf_maxfiles, 10}]} ].警报处理器gen_event的…
阅读更多...
【Material-UI】Slider 组件中的 Discrete Sliders 详解

【Material-UI】Slider 组件中的 Discrete Sliders 详解

文章目录 一、Slider 组件概述1. 组件介绍2. Discrete Sliders 的特点 二、Discrete Sliders 的基本用法1. step 属性2. marks 属性3. valueLabelDisplay 属性 三、深入理解 Discrete Sliders 的配置1. 自定义刻度标记2. 限制可选值3. 设置较小的步长4. 始终显示值标签 四、应用…
阅读更多...
Win10+GTX1050Ti安装Pytorch

Win10+GTX1050Ti安装Pytorch

目的 本文主要记录自己安装pytorch过程。 环境&#xff1a;win10 pycharm 显卡&#xff1a;GTX1050Ti 过程记录 1、确认pytorch版本 打开pytorch官网&#xff1a;https://pytorch.org/ 选择stable 2.3.0 版本&#xff0c;CUDA有11.8及12.1&#xff0c;我们看看GTX1050Ti支持…
阅读更多...
发红包案例（java）

发红包案例（java）

User类创建 public class User {private String name;private int money;public User(){}public User(String name,int money){this.namename;this.moneymoney;}public void show(){System.out.println("Name:"name" Money:"money);}public String getNam…
阅读更多...
ruoyi-vue-pro(v3)

ruoyi-vue-pro(v3)

启动上的问题 这里第二部npm install会有问题 切换成http 解决SSL 证书问题导致的连接错误 npm config set registry http://registry.npm.taobao.org/
阅读更多...
Zookeeper 官方示例2-SyncPrimitive 代码解读（二）

Zookeeper 官方示例2-SyncPrimitive 代码解读（二）

测试命令 java jar .\ZookeeperDemo-0.0.1-SNAPSHOT.jar bTest 192.168.206.100:2181 2 1. Barrier&#xff08;阻塞原语&#xff09; 1.1 概念 [!quote] A barrier is a primitive that enables a group of processes to synchronize the beginning and the end of a comput…
阅读更多...
猫头虎 分享：Python库 NumPy 的简介、安装、用法详解入门教程

猫头虎 分享：Python库 NumPy 的简介、安装、用法详解入门教程

猫头虎 分享&#xff1a;Python库 NumPy 的简介、安装、用法详解入门教程 &#x1f431;&#x1f42f; 摘要 在Python编程领域&#xff0c;特别是人工智能和数据科学方向&#xff0c;NumPy库的重要性不言而喻。 作为一个强大且广泛使用的库&#xff0c;NumPy为我们提供了处理…
阅读更多...
WLAN原理实验简述——AP上线

WLAN原理实验简述——AP上线

一、需求&#xff1a; AP通过AC上线。 AC通过控制VLAN管理AP,创建VLAN100和放行。 AP同AC建立CAPWAP关系。 二、实验拓扑图&#xff1a; 三、实验步骤&#xff1a; LSW1: sys Enter system view, return user view with CtrlZ. [Huawei]Sysname lsw1 [lsw1]undo info enable I…
阅读更多...
vue-ueditor-wrap设置autoHeightEnabled：true无效问题

vue-ueditor-wrap设置autoHeightEnabled：true无效问题

问题描述 今天小伙伴遇到一个问题&#xff0c;使用vue-ueditor-wrap富文本编辑器&#xff0c;发现设置autoHeightEnabled为true后&#xff0c;对于某些文章&#xff0c;编辑器的高度依然没有按照实际的文章内容高度进行变化&#xff1a; 问题排查 通过调试代码发现是文章html…
阅读更多...
C语言实现经典排序算法

C语言实现经典排序算法

1.排序的概念及其运用 1.1排序的概念 排序&#xff1a;所谓排序&#xff0c;就是使一串记录&#xff0c;按照其中的某个或某些关键字的大小&#xff0c;递增或递减的排列起来的操作。 稳定性&#xff1a;假定在待排序的记录序列中&#xff0c;存在多个具有相同的关键字的记…
阅读更多...
SAP BW/BPC:实现自动执行BPC跑包程序

SAP BW/BPC:实现自动执行BPC跑包程序

作者 idan lian 如需转载备注出处 如果对你有帮助&#xff0c;请点赞收藏~~~ 用途&#xff1a;创建程序&#xff0c;跑BPC包&#xff0c;把数据从BW应用层跑到BPC,程序可放到处理链或自动作业中&#xff0c;实现定时跑包。 1.步骤 首先需要BPC顾问创建一个他们手动执行的包…
阅读更多...
数据挖掘之分类算法

数据挖掘之分类算法

分类算法是数据挖掘中常用的一类算法&#xff0c;其主要任务是根据已知的训练数据&#xff08;即带有标签的数据&#xff09;构建模型&#xff0c;然后利用该模型对新的数据进行分类。分类算法广泛应用于金融、医疗、市场营销等领域&#xff0c;用于预测、决策支持等任务。以下…
阅读更多...
并查集【算法 12】

并查集【算法 12】

并查集 (Union-Find) 的基础概念与实现 并查集&#xff08;Union-Find&#xff09;是一种用于处理不相交集合&#xff08;disjoint sets&#xff09;的数据结构&#xff0c;常用于解决连通性问题。典型的应用场景包括动态连通性问题&#xff08;如网络节点连通性检测&#xff0…
阅读更多...
数据库sqlite3

数据库sqlite3

数据库 数组、链表、变量 ----->内存&#xff1a;程序运行结束&#xff0c;掉电数据丢失 文件 ----------------------->硬盘&#xff1a;程序运行结束&#xff0c;掉电数据不丢失 数据库&#xff1a;专业存储数据、大量数据 ----->硬盘 常用数据库&#xff1a; …
阅读更多...
linux 如何查看cpu核心数量

linux 如何查看cpu核心数量

在Linux系统中&#xff0c;有多种方法可以查看CPU的核心数量。 一、lscpu lscpu命令是最直接的方法之一&#xff0c;它可以显示CPU架构信息&#xff0c;包括CPU数量、每个CPU的核心数、每个核心的线程数等。要查看CPU核心数量&#xff0c;可以直接查看lscpu命令输出的Core(s) …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023