STL之优先级队列（堆）的模拟实现与仿函数(8千字长文详解！)

最新推荐文章于 2024-05-22 00:03:53 发布
最新推荐文章于 2024-05-22 00:03:53 发布
阅读量368 收藏 1
点赞数 1
分类专栏： c++ 带你深入理解数据结构！ 文章标签： c++ java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74376760/article/details/131161335
版权

STL之优先级队列（堆）的模拟实现与仿函数

文章目录

优先级队列的概念

  1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。

    本质就是一个堆！

  2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。

  3. . 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

  4. 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

    • empty()：检测容器是否为空
    • size()：返回容器中有效元素个数
    • front()：返回容器中第一个元素的引用
    • push_back()：在容器尾部插入元素
    • pop_back()：删除容器尾部元素

  5. 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。

  6. 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作
    list不支持随机访问！所以不能当做其标准容器类！
    image-20230404085935472

priority_queue的接口介绍

image-20230404091043943

pop：删除堆顶的数据

top：取出堆顶的数据

push：向堆插入数据

size：返回堆里面的元素个数

empty：判断堆是否为空

swap：交换两个堆

优先级队列的构造函数

image-20230404103606290

可以使用迭代器进行初始化！

但是这个迭代器是一个随机迭代器！

image-20230404093514444

//简单使用
#pragma once
#include <queue>
#include<iostream>
#include <functional>//less和greater的头文件
using namespace std;
int main()
{
	//大堆
	priority_queue <int> pq;
	pq.push(3);
	pq.push(1);
	pq.push(2);
	pq.push(5);
	while (!pq.empty())
	{
		cout << pq.top() << ' ';
		pq.pop();
	}
	cout << endl;

	//小堆
	priority_queue <int,vector<int>,greater<int>> pq1;
	pq1.push(3);
	pq1.push(1);
	pq1.push(2);
	pq1.push(5);
	while (!pq1.empty())
	{
		cout << pq1.top() << ' ';
		pq1.pop();
	}
	cout << endl;
	return 0;
}

image-20230404101642622

priority_queue模拟实现

容器适配器是不需要迭代器的！如果有了迭代器是不能保证最大/最小的先出！

类成员

namespace MySTL
{
	template<class T,class Container = std::vector<T>>
	class priority_queue
	{
	private:
		Container _con;
	};
}

构造函数

namespace MySTL
{
	template<class T,class Container = std::vector<T>>
	class priority_queue
	{
	public:
		priority_queue()
		{}
		template<class InputIterator>
		priority_queue(InputIterator first,InputIterator last)
			:_con(first,last)//直接调用vector的构造
		{
			//此时还不是堆！
			//向下调整建堆！
			for (int i = (_con.size() - 2) / 2; i >= 0; i++)
			{
				adjust_down(i);
			}
		}
	private:
		Container _con;
	};
}
向下调整算法——正常实现
namespace MySTL
{
	template<class T,class Container = std::vector<T>>
	class priority_queue
	{
	private:
		void adjust_down(size_t parent)
		{
			size_t  child = parent*2 +1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && _con[child] < _con[child + 1])
					child++;

				if (_con[parent] < _con[child])//建大堆
				{
					std::swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;//没有更大的了，退出
				}
			}
		}
	private:
		Container _con;
	};
}

向下调整算法的核心将父节点和自己的两个子节点对比，找到其中一个最大（大堆）的或者最小（小堆）的子节点！然后比较，如果是建大堆，若父节点比子节点还要小，那么交换！如果是建小堆，若父节点比子节点还要大，那么交换！，直到父节点比最大子节点还要大（大堆），或者是比最小的子节点还要小（小堆）则跳出循环！或者直接调整到最后一个节点！

push

namespace MySTL
{
	template<class T,class Container = std::vector<T>>
	class priority_queue
	{
	public:
		void push(const T& value)
		{
			//插入后要保持堆的结构！
			//要进行向上调整！
			_con.push_back(value);
			adjust_up(_con.size()-1);
		}
	private:
		Container _con;
	};
}
向上调整——正常实现
namespace MySTL
{
	template<class T,class Container = std::vector<T>>
	class priority_queue
	{
	private:
		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			while (child > 0)
			{
				if (_con[child] > _con[parent])//建大堆！
				{
					std::swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
	private:
		Container _con;
	};
}
//这里如果使用parent>0，那么因为子节点还在下一个位置，则无法调整根节点
//如果是parent>=0 因为parent =（0-1）/2 仍然为0，则就会出现死循环！

向上调整，就是将现在子节点和父节点对比一下！然后如果是建大堆，若子节点大于父节点那么进行交换！

如果是建小堆，若子节点小于父节点，那么也交换！

结束条件：直到根节点是孩子，或者建大堆的时候，孩子比父亲小（建小堆的时候，孩子比父亲大！）

向上调整算最好使用孩子作为循环借宿的条件！

image-20220911145454242.png

pop

namespace MySTL
{
	template<class T,class Container = std::vector<T>>
	class priority_queue
	{
	public:
		void pop()
		{
			//交换
			std::swap(_con[0], _con[_con.size()-1]);
			//删除最后一个元素
			_con.pop_back();
			//向下调整算法！
			adjust_down(0);
		}
	private:
		void adjust_down(size_t parent)
		{
			size_t  child = parent*2 +1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && _con[child] < _con[child + 1])
					child++;

				if (_con[parent] < _con[child])//建大堆
				{
					std::swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;//没有更大的了，退出
				}
			}
		}
	private:
		Container _con;
	};
}

image-20221020172922446.png

int main()
{
	MySTL::priority_queue <int> pq;
	pq.push(3);
	pq.push(1);
	pq.push(2);
	pq.push(5);
	while (!pq.empty())
	{
		cout << pq.top() << ' ';
		pq.pop();
	}
	cout << endl;
	return 0;
}

image-20230405113500474

仿函数/函数对象

仿函数的概念

首先仿函数究竟是什么呢？——是一个类！仿函数的类型对象我们叫做函数对象！

template<class T>
struct less
{
	bool operator()(const T& x,const T& y)
	{
		return x < y;
	}
};
template<class T>
struct greater
{
	bool operator()(const T& x,const T& y)
	{
		return x > y;
	}
};

仿函数的要求是要重载()，()这也是一个运算符！例如像是我们去调用pq1.pop()的函数，后面的()就是一个函数调用符！

int main()
{
	less<int> lessFunc;
	lessFunc(0, 1);
	return 0;
}

如果不看上面的类的定义，单看后面的lessFunc(0,1)，这就是一个函数调用！函数名是lessFunc——但是现在实际上是一个类！这就是为什么这个叫做仿函数！这个对象叫做函数对象！指的就是这个对象能像函数一样被使用！

但是这个其实也是一个函数调用

lessFunc(0, 1);//将这个转换为一个运算符重载！
lessFunc.operator()(0, 1);//等价于上面上面的！

仿函数的作用

那么仿函数究竟有什么作用呢？看起来和一般的函数区别？而且还多了一个封装！看起来更加的麻烦了！

我们可以举一个例子来看

//这是C语言的一个冒泡排序！
void BubbleSort(int* a, int size,bool(*cmp)(int,int))
{
	for (int i = 0; i < size; i++)
	{
		int exchange = 0;
		for(int j = 1.;j<size-i;j++)
		{
			if (cmp(a[j-1],a[j]))
			{
				std::swap(a[j - 1], a[j]);
				exchange = 1;
			}
		}
		if (!exchange)
		{
			break;
		}
	}
}

我们可以 看到在C语言中，如果我们想要解决升序降序的问题，我们就要传一个函数指针过来！——如果不用函数指针那么我们就只能重新写一个函数了！

那么在C++中的类里面我们是否也可以传一个函数指针呢？可以！但是这样子不好看！C++的设计都是在尽量的不去使用指针！

所以仿函数这时候就派上用场了！

template <class T,class Compare>
void BubbleSort(T* a, int size,Compare com)//因为Compare其实是一个类所以要显示实例化！而不是模板函数一样是推演实例化！所以要多加一个参数
{
	for (int i = 0; i < size; i++)
	{
		int exchange = 0;
		for(int j = 1.;j<size-i;j++)
		{
			//if (a[j] < a[j - 1])
			if (com(a[j], a[j - 1]))
			{
				std::swap(a[j - 1], a[j]);
				exchange = 1;
			}
		}
		if (!exchange)
		{
			break;
		}
	}
}

int main()
{
	less<int> lessFunc;
	int a[] = { 1,5,7,8,94,24,5,3,56,7 ,90 };
	BubbleSort(a, sizeof(a) / sizeof(a[0]), lessFunc);//升序排序
	//BubbleSort(a, sizeof(a) / sizeof(a[0]), less<int>());
    //怎么写也是可以的！因为是一个匿名对象！如果这个函数对象是要使用一次的话！可以直接使用！匿名对象！
	for (auto& e : a)
	{
		std::cout << e << " ";
	}
	std::cout << std::endl;
	greater<int> greaterFunc;
	int b[] = { 1,5,7,8,94,24,5,3,56,7 ,90 };
	BubbleSort(b, sizeof(b) / sizeof(b[0]), greaterFunc);//降序排序！
	//BubbleSort(b, sizeof(b) / sizeof(b[0]), greater<int>());
	for (auto& e : b)
	{
		std::cout << e << " ";
	}
	return 0;
}

image-20230405175758557

less和greater就是我们刚刚写的仿函数！

从我们实现代码的角度来说，这是一个泛型，是一个逻辑泛型——即com是一个逻辑！如果需要升序就传一个lessFunc，如果要降序就传一个greaterFunc

类型泛型就是不限类型！逻辑泛型就是不限逻辑！

仿函数一般都是传值，因为仿函数的拷贝代价很小！仿函数里面没有成员变量！所以只有一个字节作为标记位！

但是如果想要传引用也行！

void BubbleSort(T* a, int size,const Compare& com)//也是可以传引用的！但是要加上const否则就无法接收匿名对象！因为匿名对象具有常性
{
	for (int i = 0; i < size; i++)
	{
		int exchange = 0;
		for(int j = 1.;j<size-i;j++)
		{
			//if (a[j] < a[j - 1])
			if (com(a[j], a[j - 1]))//因为是const对象调用所以仿函数内部都要加上const
			{
				std::swap(a[j - 1], a[j]);
				exchange = 1;
			}
		}
		if (!exchange)
		{
			break;
		}
	}
}

template<class T>
struct less
{
	bool operator()(const T& x,const T& y)const//加上const让const对象能够调用！
	{
		return x < y;
	}
};
template<class T>
struct greater
{
	bool operator()(const T& x,const T& y)const
	{
		return x > y;
	}
};

我们也可以看到传引用其实很麻烦！所以没有什么必要！

使用仿函数来实现优先级队列的逻辑判断

我们上面的优先级队列要么只能是大堆！要么只能是小堆！不够泛用！原因就是因为我们的逻辑是写死的！但是学会了仿函数之后！我们也可以实现逻辑泛型了！

新增模板参数

	template<class T, class Container = std::vector<T>,class Compare = less<T>> 
	class priority_queue
	{
	public:
        // functions
	private:
		Container _con;
	};
}

加上第三个模板参数仿函数！

使用仿函数实现泛型的向下调整算法与向上调整算法

namespace MySTL
{
	template<class T>
	struct less
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};
	template<class T>
	struct greater
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};
	template<class T, class Container = std::vector<T>,class Compare = less<T>>
	class priority_queue
	{
	public:
        //functions
	private:
		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			Compare com;
			while (child > 0)
			{
				//if (_con[child] > _con[parent])//建大堆！
				//if (_con[parent] < _con[child])//建大堆！
				if(com(_con[parent], _con[child]))//我们要与库保持一致要小于实现大堆！那么就要parent在前，就是与上面的逻辑一样
				{
					std::swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void adjust_down(size_t parent)
		{
			size_t  child = parent*2 +1;
			Compare com;
			while (child < _con.size())
			{
				//if (child + 1 < _con.size() && _con[child] <  _con[child + 1]))
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1])))//我们要与库保持一致要小于实现大堆！那么就要child在前
					child++;

				//if (_con[parent] < _con[child])//建大堆
				if(com(_con[parent], _con[child]))
				{
					std::swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;//没有更大的了，退出
				}
			}
		}
	private:
		Container _con;
	};
}

测试用例

int main()
{
	//大堆
	MySTL::priority_queue <int> pq;
	pq.push(3);
	pq.push(1);
	pq.push(2);
	pq.push(5);
	while (!pq.empty())
	{
		cout << pq.top() << ' ';
		pq.pop();
	}
	cout << endl;

	//小堆
	MySTL::priority_queue <int, vector<int>, greater<int>> pq1;
	pq1.push(3);
	pq1.push(1);
	pq1.push(2);
	pq1.push(5);
	while (!pq1.empty())
	{
		cout << pq1.top() << ' ';
		pq1.pop();
	}
	cout << endl;
	return 0;
}

image-20230405205825084

优先级队列模拟——最终版代码

namespace MySTL
{
	template<class T>
	struct less
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};
	template<class T>
	struct greater
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};
	template<class T, class Container = std::vector<T>,class Compare = less<T>>
	class priority_queue
	{
	public:
		priority_queue()//无参构造
		{}
		template<class InputIterator>
		priority_queue(InputIterator first, InputIterator last)
			:_con(first, last)//直接调用vector的构造
		{
			//此时还不是堆！
			//向下调整建堆！
			for (int i = (_con.size() - 2) / 2; i >= 0; i++)
			{
				adjust_down(i);
			}
		}
		void push(const T& value)
		{
			_con.push_back(value);
			adjust_up(_con.size()-1);
		}
		void pop()
		{
			//交换
			std::swap(_con[0], _con[_con.size()-1]);
			//删除最后一个元素
			_con.pop_back();
			//向下调整算法！
			adjust_down(0);
		}
		const T& top() const
		{
			return _con[0];
		}
		bool empty() const
		{
			return _con.empty();
		}
		size_t size()const
		{
			return _con.size();
		}

	private:
		void adjust_up(size_t child)
		{
			size_t parent = (child - 1) / 2;
			Compare com;
			while (child > 0)
			{
				//if (_con[child] > _con[parent])//建大堆！
				//if (_con[parent] < _con[child])//建大堆！
				if(com(_con[parent], _con[child]))//我们要与库保持一致要小于实现大堆！那么就要parent在前
				{
					std::swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void adjust_down(size_t parent)
		{
			size_t  child = parent*2 +1;
			Compare com;
			while (child < _con.size())
			{
				//if (child + 1 < _con.size() && _con[child] <  _con[child + 1])
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))//我们要与库保持一致要小于实现大堆！那么就要child在前
					child++;

				//if (_con[parent] < _con[child])//建大堆
				if(com(_con[parent], _con[child]))
				{
					std::swap(_con[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;//没有更大的了，退出
				}
			}
		}
	private:
		Container _con;
	};
}

仿函数的应用

要知道我们优先级队列的类型可以不只是库里面的类型！还可以是自定义类型！

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}

	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}

	friend ostream& operator<<(ostream& _cout, const Date& d)
	{
		_cout << d._year << "-" << d._month << "-" << d._day;
		return _cout;
	}

private:
	int _year;
	int _month;
	int _day;
};

如果一个自定义类型是支持比较大小的！那么仿函数greater和less都是可以使用的！里面的>与< 本质也是调用的是Date类的运算符重载！

void testpriorityqueue()
{
	priority_queue<Date> q1;//默认是大堆
	q1.push(Date(2010, 1, 1));
	q1.push(Date(2010, 1, 2));
	q1.push(Date(2010, 1, 3));
	cout << q1.top() << endl;

	priority_queue<Date,vector<Date>,greater<Date>> q2;//默认是大堆
	q2.push(Date(2010, 1, 1));
	q2.push(Date(2010, 1, 2));
	q2.push(Date(2010, 1, 3));
	cout << q2.top() << endl;

}
int main()
{
	testpriorityqueue();
	return 0;
}

现在如果我们传入的是这个自定义类型的指针呢？

void testpriorityqueue()
{
	//大堆
	priority_queue<Date*> q3;
	q3.push(new Date(2010, 1, 1));
	q3.push(new Date(2010, 1, 2));
	q3.push(new Date(2010, 1, 3)); 
	cout << *q3.top() << endl;
	//小堆
	priority_queue<Date*,vector<Date*>,greater<Date*>> q4;/
	q4.push(new Date(2010, 1, 1));
	q4.push(new Date(2010, 1, 2));
	q4.push(new Date(2010, 1, 3));
	cout << *q4.top() << endl;
}
int main()
{
	testpriorityqueue();
	return 0;
}

image-20230406092317205

我们发现这时候堆的比较好像就失效了!这是为什么呢？因为我们传过去的是date类的地址！此时我们传入的仿函数是用地址的大小去比较的！谁地址谁大！谁地址小谁小！

因为每次地址是随机的！所以每次的结果都会在改变！

那么现在的结果已经不符合我们预期了！怎么办？

我们就可以重新写一个关Date* 的仿函数！

struct PDateCompare_greater
{
	bool operator()(const Date* x,const Date* y)
	{
		return *x > *y;
	}
};
struct PDateCompare_less
{
	bool operator()(const Date* x,const Date* y)
	{
		return *x < *y;
	}
};
void testpriorityqueue()
{
	//大堆
	//priority_queue<Date*> q3;
	priority_queue<Date*,vector<Date*>,PDateCompare_less> q3;
	q3.push(new Date(2010, 1, 1));
	q3.push(new Date(2010, 1, 2));
	q3.push(new Date(2010, 1, 3)); 
	cout << *q3.top() << endl;
    
	//小堆
	priority_queue<Date*,vector<Date*>,PDateCompare_greater> q4;
	q4.push(new Date(2010, 1, 1));
	q4.push(new Date(2010, 1, 2));
	q4.push(new Date(2010, 1, 3));
	cout << *q4.top() << endl;
}
int main()
{
	testpriorityqueue();
	return 0;
}

image-20230406100002253

如果比较的方式不是我们想要的！那么我们就可以通过自己写一个仿函数来完成，甚至如果自定义类不支持> 与< 重载我们也可以写一个仿函数来完成大小的比较！

STL中实现的比较

image-20230406103953230

STL中的建堆算法

STL中的建堆算法是在algorithm这个头文件中！

image-20230406104415345

  • push_heap将一个元素插入堆中
  • pop_heap将一个元素从堆中移除
  • make_heap 从一个范围内的元素中创建一个堆
  • sort_heap 堆排序！
  • if_heap 判定一个范围内的元素是不是堆
  • is_heap_until 找到第一个不按堆规则的元素
为世界献上祝福
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++之模板特性详解！（3千字长文）
m0_74376760的博客
04-05 459
C++之模板特性详解！（3千字长文）
c++面试之葵花宝典
qwq_ly的博客
10-20 411
c++面试之随便写写 C++基础 虚函数的实现 表现形式：在类中的成员函数前加上一个关键字virtual 本质：如果一个类中存在虚函数，那么这个类中的“第一个成员”就是一个虚表指针，虚表指针指向的是一个虚函数表，虚函数表里存放的是这个类中每个虚函数的入口地址。在构造函数中进行虚表的创建和虚表指针的初始化。 当基类和子类都包含虚函数的时候，子类会继承基类的虚函数表，如果子类没有重写父类的虚函数，那么用一个指针/引用调用某个方法是，要看这个指针/引用指向的是基类对象还是子类对象，指向基类对象的指针/引用就调用基
机试，蓝桥，PAT常用，一定要记住的！！！
qq_43992949的博客
11-02 845
笔者泡泡最近刷题时记录的一些笔记，笔记内容比较详细基础，每个笔记基本上都有相关的应用解析链接，对于机试，竞赛小白而言是可以加快大家入门的速度，对于即将机试的同学也可以用来复习，笔记会持续更新，如有需要可以关注我哦！
六一儿童节倾情奉献，校内首发，CSDN再发，2011年冬季c/c++程序员找工作心得
feitianxuxue的专栏
06-01 5794
六一儿童节倾情奉献，校内首发，CSDN再发，2011年冬季c/c++程序员找工作心得   我把2011年末2个月去的公司，遇到的问题整理出来，自己复习下，也供大家参考。其实没什么经验，也就是流水账。对部分公司我也发表了自己的观点，不过纯属自己的体会，给大家参考下。 所有的笔试题目都是部分的，我记录下的都是自己认为比较经典的，要么就是我不太会的，至于一些常考的，简单的不能再简单的，就没有必要记
STL priority_queue（优先队列）详解
09-01
主要介绍了 STL priority_queue（优先队列）详解的相关资料,需要的朋友可以参考下
浅析stl序列容器(map和set)的仿函数排序
09-05
有序的stl容器在工程中应用什么方便和广泛，但是当我们需要自己的排序的时候，可以用仿函数来设置它
如何使用STL编程实现PLC控制系统的模拟量信号和采样与滤波
07-07
从工程实际出发，介绍了PLC（可编程序控制器）控制系统中模拟量信号的采样和滤波方法，并以S7300PLC语句表（STL）编程为例，给出了部分程序或程序流程图，并用仿真和应用实例证明了其有效性和可行性.
PriorityQueue-MEX-Matlab:这是 C++ STL 优先级队列的 Mexified MATLAB 包装器-matlab开发
05-29
这是 C++ STL 优先级队列的 Mexified MATLAB 包装器这个优先队列实现很简单。 然而，它可以用来保存任意对象的“排序”列表。 我们可以只推送它的索引，而不是推送整个对象。 这是通过首先像往常一样将对象存储在 ...
C语言简要（四）
m0_74057302的博客
05-21 85
有没有好心师傅教教孩子逆向和pwn啊°꒰๑'ꀾ'๑꒱°
C语言 变量的存储类型
weixin_45966674的博客
05-21 197
今天 我们来说变量的存储类型变量的存储类型是指系统为变量分配存储区域的方式。决定着变量存储空间在哪里分配，和变量的生存期、作用域存在着一定联系。
C++原创人工智能QPBS01G大功告成！！！
QIPABOSHI的博客
05-21 159
这次这娃学聪明了，遇到不会的问题上网搜，我还更新了反骂人骂人功能，第一次测试我加了个关机功能，他一说完话就关机了，我草，烦烦烦烦烦烦烦烦烦烦烦烦烦烦烦烦死了！我之前的版本bug太多，结果这两天晚上改的我两眼发白，太烦人了。俗话说得好，你周五周六不写作业，要上学了才着急了。
[C][数组]详细讲解
最新发布
SnowK博客
05-22 1308
[C][数组]详细讲解
Ubuntu16.04 opencv环境搭建（C++）
hkj887tg的博客
05-21 408
Ubuntu下vscode跑opencv程序环境搭建。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 263
C语言如何在链表中的指定位置插⼊结点？
C++ 11
qq_65112813的博客
05-17 654
对于类类型，如果定义了接受。
手搓顺序表（C语言）
m0_62646213的博客
05-19 814
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
PointCloudLib 点云随机降采样 C++版本
linux_huangyu的博客
05-21 3
随机降采样是众多降采样算法中，速度最快的（应该是），多次测试之后感觉降采样还是比较平均。
在Visual Studio Code和Visual Studio 2022下配置Clang-Format，格式化成Google C++ Style
beyond谚语的博客
05-21 266
在Visual Studio Code和Visual Studio 2022下配置Clang-Format，格式化成Google C++ Style
STL 容器中优先级队列 deque 的底层原理
03-08
优先级队列 deque 的底层原理是使用一个双端队列来存储元素，并使用一个堆来维护队列中元素的优先级。堆是一种完全二叉树，可以使用数组来实现。在 deque 中，每个元素都有一个优先级，优先级高的元素会被先出队列。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

为世界献上祝福

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值