C++ - 优先级队列(priority_queue)的介绍和模拟实现 - 反向迭代器的适配器实现 - 仿函数

 仿函数

 所谓仿函数,其实它本身不是一个函数,而是一个类,在这个类当中重载了  operator() 这个操作符,那么在外部使用这个类的 operator() 这个成员函数的时候,使用的形式就像是在使用一个函数一样,仿函数(函数对象)这个类的对象可以像函数一样使用。如下就是定义的一个仿函数:

// 简单仿函数的定义
class Less
{
public:
	bool operator()(int x, int y)
	{
		return x < y;
	}
};

像上述 less 类当中 就定义个一个 operator() 运算符重载函数,在外面使用这个函数的时候如下所示:

Less newLess;
cout << newLess(1 , 2) << endl;

 由上述例子我们发现,如果不看多定义的 newLess 对象的话,在 流插入当中使用 形式就像是在使用函数一样,其实上述的代码等价于下面这个代码

cout << newLess.operator()(1 , 2) << endl;

C++ 当中定义 仿函数只要是想要替代C当中哈数指针 。

使用方式:因为仿函数的使用方式是类似于调用函数,那么我们就可以定义多个仿函数(类),然后再使用模版来使用这些类(因为模版是需要用类型的,模版参数是类型直接使用函数不能套用模版),那么也就相当于一个位置可以使用多个函数。也就是把某一个位置写活了,而不是单纯的写死。

比如: 
 

func(bool x)
{
    if(x)
    {
        cout << "yes" << endl;
    }
}

class less
{
    bool operator()(int x , int y)
    {
        return x > y;
    }
}

class greater
{
    bool operator()(int x , int y)
    {
        return x < y;
    }
}

template>
class My_class
{
public:
    void My_class_func()
    {
        Comapre com;
        int x = 10, y = 20;
        //func(x < y);  不用这样写死了
        func(com(x , y)); // 这样写看按照传入的Comapre 是什么函数模版来给func函数传入不同值
    }
}

 如上所示,只要在外部创建 My_class 的对象的时候,给的第二个模版参数是 less 那么,给func函数传入的就是 x > y 的bool值;如果传入的参数是 greater,那么给 func 函数传入的就是 x < y 的bool值。

这里就解决了,模版参数当中只能传入类型,如果我们想用模版来套用不同的函数,从而实现某一些代码的变化。 

优先级队列

 头文件   

 优先级队列本质也是一个容器适配器,它默认的容器是 vector 容器:

 容器主要功能如下:

C++ - 优先级队列(priority_queue)的介绍和模拟实现 - 反向迭代器的适配器实现 - 仿函数_第1张图片

函数声明 接口说明
priority_queue()/priority_queue(first,
last)
构造一个空的优先级队列
empty( ) 检测优先级队列是否为空,是返回true,否则返回
false
top( ) 返回优先级队列中最大(最小元素),即堆顶元素
push(x) 在优先级队列中插入元素x
pop() 删除优先级队列中最大(最小)元素,即堆顶元素

 我们发现,功能函数的实现和 堆 类似,其实 优先级队列的底层实现就是 二叉树当中的 堆。

 根据堆的特性,优先级队列也是不支持遍历的,也就不支持迭代器,也是需要像 队列 和 栈一样 pop()掉元素才能取到所有的数据。 如下代码演示:

void text1()
{
	priority_queue pq;
	pq.push(5);
	pq.push(3);
	pq.push(1);
	pq.push(2);

	while (!pq.empty())
	{
		cout << pq.top() << " ";
		pq.pop();
	}
	cout << endl;

}

 输出:
5 3 2 1

 priority_queue 默认是大堆,在上述的模版参数当中也可以看出:

class Compare = less

这个参数控制了 这个 优先级队列是大堆还是小堆,这里给点缺省参数是 小堆。只不过这个缺省参数是给的不太一样,上述 less 是小于的意思,但是这里表达的意思是 大堆的意思,可以说是一个开发过程化当中的一个失误。

对于 小堆的 和 大堆的控制如下所示:

priority_queue , less>      // 大堆的创建
priority_queue , greater>  //  小堆的创建

这里控制小堆和大堆,使用仿函数来实现的

对于堆的使用,看下面这个例题:力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台

 题目要求:

给定整数数组 nums 和整数 k,请返回数组中第 k 个最大的元素。

请注意,你需要找的是数组排序后的第 k 个最大的元素,而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

 这里就可以用堆来解决,那么建大堆还是小堆呢?

本来排升序是需要建大堆的,但是这里数据量少,所以建小堆和大堆都是可以的。

建大堆代码;

    int findKthLargest(vector& nums, int k) {
        priority_queue pq(nums.begin(), nums.end());

        while(--k)
        {
            pq.pop();
        }

        return pq.top();

    }

建小堆代码:

          int findKthLargest(vector& nums, int k) {

    priority_queue , greater> pq(nums.begin(), nums.begin() + k);

       for(int i = k;i < nums.size();i++)
       {
           if(nums[i] > pq.top())
           {
               pq.pop();
               pq.push(nums[i]);
           }
       }

        return pq.top();
    }

priority_queue 优先级队列的模拟实现

 关于容器适配器的介绍请看下面这博客,这里不再多讲:

 大体框架

#pragma once
#include

namespace My_priority_queue
{
	template>
	class priority_queue
	{
	private:

    private:
		Container _con;
	};
}

构造函数

 支持自己 或 其他容器的迭代器区间的 构造函数

	private:
		void Adjustdown(int parent)
		{
			int child = parent * 2 + 1;
			while (child < _con.size())
			{
				if (child + 1 < _con.size() && _con[child] < _con[child + 1])
				{
					++child;
				}

				if (_con[child] > _con[parent])
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
	public:
		template
		priority_queue(priority_queue first, priority_queue last)
		{
			while (first != last)
			{
				_con.push_back(*first);
				++first;
			}

			// 建堆 向下调整建大堆
			for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
			{
				Adjustdown(i);
			}
		}

这里主要实现就是, 先把数据从其他容器当中拷贝到 存储 堆 的容器当中,然后进行向下调整建大堆。堆的具体实现过程可以参考下面博客当中对于堆排序的介绍:(1条消息) 数据结构(c语言版)-5_为这个查询提供一个最大化p ai 5的排序实例_chihiro1122的博客-CSDN博客

 增删查改

 pop()

 堆的删除不能直接对 堆顶 的元素进行删除,然后再把元素按照数组的方式向前移动。这样是不行的,如果这样做的话,整个 堆 的父亲 和  孩子 的关系,全乱了。

我们需要把 堆顶元素和 数组最后一个元素进行交换,然后删除数组最后一个元素,在把堆顶的元素进行向下调整建堆

		void pop()
		{
			swap(_con[0], _con[_con, size() - 1]);
			_con.pop_back();
			Adjustdown(0);
		}

push()

 往数组最后一个位置插入,然后对数组最后一个位置的元素进行向上调整即可:

// 向上调整
		void adjustup(int child)
		{
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				if (_con[child] > _con[parent])
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		// 插入元素
		void push(const T& x)
		{
			_con.push_back(x);
			adjustup(_con.size());
		}

其他函数

 包括top()函数   size() 函数  empty()函数。

		// 取堆顶的元素
		const T& top()
		{
			return _con[0];
		}

		// 堆元素个数
		size_t size()
		{
			return _con.size();
		}

		// 堆的判空
		bool empty()
		{
			return _con.empty();
		}

仿函数实现 priority_queue 的大堆和小堆的选择

 我们上述已经说过了 仿函数的用法,那么这里就直接用到 priority_queue 当中,因为建大堆和建小堆的区别,就在与向上调整和向下调整两个函数的 孩子结点和 双亲结点的大小比较关系,所以中替换这个两个函数即可:

两个仿函数,Less类实现的是大堆;Greater类实现的是小堆:

	template
	class Less
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	template
	class Greater
	{
	public:
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

下面是对 向上调整和向下调整的改进:
 

// 向下调整
		void Adjustdown(int parent)
		{
			Comapre com;

			int child = parent * 2 + 1;
			while (child < _con.size())
			{
				//
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
				{
					++child;
				}

				// 
				if (com(_con[parent], _con[child]))
				{
					swap(_con[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}

		// 向上调整
		void adjustup(int child)
		{
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				//_con[parent] < _con[child]
				if (com(_con[parent] < _con[child]))
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

注意:因为我们上述实现的仿函数只是单纯的比较大小,如果是内置类型那么没有问题;但如果是自定义类型,那么这个类型必须要重载 operator< 和 operator> 这两个重载函数,不然会编译报错。

除了实现 operator< 和 operator> 这两个重载函数,像上述实现的仿函数其实在库当中已经实现了的,在库当中也是用 " < " " > " 来计算的,所以,其实这个仿函数我们可以不自己实现,直接用库当中的仿函数。

但是使用库当中的仿函数还是弊端,假设使用的自定义类没有实现 operator< 和 operator> 这两个重载函数,那么我们需要自己在仿函数当中去实现;其实这种情况是可以避免的,一般来说 operator< 和 operator> 这两个重载函数 在自定义类型当中就应该实现。

除了上述说的一种情况,还有一种情况,如下代码所示:

	My_priority_queue::priority_queue pq;
	pq.push(new Date(2023, 7, 1));
	pq.push(new Date(2023, 6, 2));
	pq.push(new Date(2023, 8, 3));

在 上述的 priority_queue 容器当中存储不是一个 Date 自定义类型对象,而是存储的是对象的指针,在 push()的时候新开辟的空间。

这种情况的输出结果就非常的奇怪,我们不改变代码,多次运行 可执行程序,每一次的输出结果都是不一样的

C++ - 优先级队列(priority_queue)的介绍和模拟实现 - 反向迭代器的适配器实现 - 仿函数_第2张图片

 这时候,传入的模版参数的类似是 一个指针,那么走到仿函数当中去 比较的时候,是按照地址的大小去排序的,而每一次在空间当中开辟空间的,这个空间的位置是不确定的,所以导致了结果不一样。

如果在这种情况下,想要按照日历去排序的话,就不能按照 库当中的仿函数去走了,要自己在仿函数当中进行日期的判断。

注意:不能直接使用类当中的重载运算符函数,只能自己控制的仿函数当中去实现/使用。因为指针属于是内置类型,内置类型是不能重载运算符的,Date类当中实现的 重载运算符函数是 属于这个自定义类型的,不属于指针。如下代码所示:

struct LessPDate
{
    bool operator() (const Date* d1, const Date* d2)
    {
        return *d1 < *d2
    }
}

就要像如上方式去调用 Date类 当中重载运算符函数。

反向迭代器

 之前对 list 的正向迭代器进行了实现,list 的迭代器不再像 vector  和 string一样使用原生指针来做作为迭代器,而是把指针 用一个类 进行了包装/封装,让这个迭代器使用起来 和 vector 一样,使用 解引用(*),向后迭代(++),等等操作来使用。

反向迭代器 相比于 正向迭代器,不同的就是 (++)是向前迭代器,开始位置 和 终止位置 反过来而已,那么,我们大可以直接拷贝一份 正向迭代器的 代码,然后对 operator++ 和 operator-- 两个函数换一下,然后在完善一些 typedef 的工作等等,可以实现,但是冗余

在库 当中 list 的反向迭代器不是这样实现的:库当中的实现简单来说,在list环境下,用一个反向迭代器的类,对正向迭代器的类进行封装,(++)调用 正向迭代器当中的 (--),(--)调用 (++);

 但是其实没有这么简单。库当中是实现了一个反向迭代器的类模版(反向迭代器的适配器),只要我使用某一个类的反向迭代器,就会去调用这个 反向迭代器的类模板;也就是说,库当中用一个类模板实现了全部容器的反向迭代器。

 它并不是针对某一个类去实现的 反向迭代器,针对的是全部的容器。

 在 STL 当中,反向迭代器的代码在 stl_iterator.h 这个文件当中:

大概是这样的;

C++ - 优先级队列(priority_queue)的介绍和模拟实现 - 反向迭代器的适配器实现 - 仿函数_第3张图片

 而且,对于rend(), rbegin()的实现是 和 end (),rbegin()镜像对称的,所以我们看见了,反向迭代器当中的 解引用操作是 先 (--)后解引用的,也就是访问的是 当前位置的前一个位置:

C++ - 优先级队列(priority_queue)的介绍和模拟实现 - 反向迭代器的适配器实现 - 仿函数_第4张图片

 迭代器关系如下:

C++ - 优先级队列(priority_queue)的介绍和模拟实现 - 反向迭代器的适配器实现 - 仿函数_第5张图片

 由此可见是完全镜像的,反向迭代器和正向迭代器的位置是对称的。

反向迭代器 的 适配器 实现

 根据上述的描述,我们下述在 list 当中的反向迭代器的实现,就参照库当中的逻辑去实现。

问题:operator*的返回值问题,因为 反向迭代器不想正向迭代器是实现在 各个 容器当中的,反向迭代器没有 这个容器存储的数据类型,正向迭代器使用模版参数来知道 容器存储数据的类型的。

官方库当中,是用 萃取的 方式把容器当中存储的数据类型套出来的,但是这个方式非常的复杂。

另一种方式相对简单一些,就是让用的人,把容器的 数据类型 用模版参数传过来

 代码实现:

#pragma once

#include

using namespace std;

namespace reverse_iterator
{
	//			迭代器类型     T*         T&
	template
	class ReverseIterator
	{
		typedef ReverseIterator< iterator, Ref, ptr> self;
		iterator _it;

		ReverseIterator(it)
			:_it(it)
		{}

		Ref operator*()
		{
			iterator tmp = it;
			return *(--tmp);
		}

		ptr operator->()
		{
			return &(operator*());
		}

		self operator++()
		{
			--_it;
			return _it;
		}

		self operator--()
		{
			++_it;
			return _it;
		}

		bool operator!= (const T& x) const
		{
			return _it != x._it;
		}
	};
}

对于在类当中的实现,typedef 一下就行:

template
class xxx
{
public:
    // 非 const迭代器
    typedef ReverseIterator reverse_iterator;
    // const 迭代器
    typedef ReverseIterator const_reverse_iterator;

    reverse_iterator rbegin()
    {
        return reverse_iterator(end());
    }

    reverse_iterator rend()
    {
        return reverse_iterator(begin());
    }

    const_reverse_iteratorrbegin()
    {
        return const_reverse_iterator(end());
    }

    const_reverse_iteratorrend()
    {
        return const_reverse_iterator(begin());
    }

}

这个反向迭代器,根据给的是哪一个容器的正向迭代器,就适配哪一个的反向迭代器。

你可能感兴趣的:(c++,开发语言)