sgi 之heap, priority_queue

最新推荐文章于 2024-04-21 16:23:33 发布

原创最新推荐文章于 2024-04-21 16:23:33 发布 · 741 阅读

0 ·

CC 4.0 BY-SA版权

c++ 专栏收录该内容

178 篇文章

订阅专栏

本文深入探讨了STL中优先队列的实现原理，包括构造、上溯与下滤等关键操作，并通过具体代码示例展示了如何利用模板和迭代器来高效地维护堆结构。

heap只能算是算法，而priority_queue只是封装了vector，所以又称为配接器。

由于在下面的实现中需要获得iterator所指向的类型，所以又用到了stl中的类型萃取技术

cconstruct.h

#ifndef C_CONSTRUCT_H
#define C_CONSTRUCT_H
#include <iostream>
#include <new.h>

inline void destroy(char *, char *){}
inline void destroy(int *, int *){}
inline void destroy(long *, long *){}
inline void destroy(float *, float *){}
inline void destroy(double *, double *){}

//对于int* p，也可以调用这个函数，比较怪异
template <class T>
inline void destroy(T* pointer) {
    pointer->~T();
}

template <class ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last) {
    for (; first  < last ; ++first)
        destroy(first);
}

template <class T1, class T2>
inline void construct(T1* p, const T2& value) {
    new (p) T1(value);
}

template <class _Iter>
inline typename std::iterator_traits<_Iter>::value_type*
__value_type(const _Iter&)
{
    return static_cast<typename std::iterator_traits<_Iter>::value_type*>(0);
}

#endif

cheap.h

#ifndef C_HEAP_H 
#define C_HEAP_H
#include "cconstruct.h"
#include <iostream>

//上溯。假设要上溯的值放在堆尾
template <class RandomAccessIterator, class Compare>
void cpush_heap(RandomAccessIterator first, RandomAccessIterator last, Compare cmp ) {
    __cpush_heap(first, last, __value_type(first), cmp);
}

template <class RandomAccessIterator, class T, class Compare>
void __cpush_heap(RandomAccessIterator first, RandomAccessIterator last, T*, Compare cmp) {
    size_t holeIndex = last - first - 1;
    size_t parent = (holeIndex - 1)/2;
    T value = *(last - 1);
    while (holeIndex > 0 && cmp(*(first + parent), value)) {
        *(first + holeIndex) = *(first + parent);
        holeIndex = parent;
        parent = (holeIndex - 1)/2;
    }
    *(first + holeIndex) = value;
}

//上溯操作只适用于在尾部添加元素，维持堆特性的操作

template <class RandomAccessIterator, class Compare>
void cpop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare cmp) {
    __cpop_heap(first, last, __value_type(first), cmp);
}

template <class RandomAccessIterator, class T, class Compare>
void __cpop_heap(RandomAccessIterator first, RandomAccessIterator last, T*, Compare cmp) {
    T value = *(last - 1);
    *(last - 1) = *first;
    __cadjust_heap(first, 0, last - first - 1, value, cmp);//注意，此时的长度就不应该算上堆尾
}

//向下走。value本来放在holeIndex
template <class RandomAccessIterator, class T, class Compare>
void __cadjust_heap(RandomAccessIterator first, size_t holeIndex, size_t len, T value, Compare cmp) {
    size_t firstChild = 2* holeIndex + 1;
    for ( ; firstChild < len; firstChild = 2* firstChild + 1) {
        if (firstChild + 1 < len && cmp(*(first + firstChild ), *(first + firstChild + 1)))
            ++firstChild;
        if (!cmp(value, *(first + firstChild) ))//value >= child
            break;
        *(first + holeIndex) = *(first + firstChild);
        holeIndex = firstChild;

    }
    *(first + holeIndex) = value;
}

//输入必须是已经成堆的
template <class RandomAccessIterator, class Compare>
void csort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare cmp) {
    while (last - first > 1) cpop_heap(first, last--, cmp);
}

template <class RandomAccessIterator, class Compare>
void cmake_heap(RandomAccessIterator first, RandomAccessIterator last, Compare cmp) {
    __cmake_heap(first, last, __value_type(first), cmp);
}

template <class RandomAccessIterator, class T,class Compare>
void __cmake_heap(RandomAccessIterator first, RandomAccessIterator last, T*, Compare cmp) {
    if (last - first < 2) return;
    size_t len = last - first;
    size_t holeIndex = (len - 2)/2;//从底向上，第一棵子树的头
    while (true) {
        __cadjust_heap(first, holeIndex, len, *(first + holeIndex), cmp);
        if (holeIndex == 0) return;
        --holeIndex;
    }
   
}


#endif

cqueue.h

#ifndef C_QUEUE_H
#define C_QUEUE_H
#include "cvector.h"
#include "cheap.h"
#include <iostream>

template <class T, class Seq = cvector<T>, class Compare = less<typename Seq::value_type> >
class cpriority_queue {
public:
    typedef typename Seq::value_type value_type;
    typedef typename Seq::reference reference;
    typedef typename Seq::const_reference const_reference;
protected:
    Seq c;//底层容器
    Compare comp;

public:
    cpriority_queue() : c() {}

    template <class InputIterator>
    cpriority_queue(InputIterator first, InputIterator last, const Compare& x)
        : c(first, last), comp(x) { cmake_heap(c.begin(), c.end(), comp); }
    
    template <class InputIterator>
    cpriority_queue(InputIterator first, InputIterator last)
        : c(first, last){ cmake_heap(c.begin(), c.end(), comp); }
    /*void show() {
        Seq::iterator first = c.begin();
        for (;first != c.end(); ++first)
            std::cout<<*first<<" ";
        std::cout<<endl;
    }*/

    bool empty() const { return c.empty(); }
    size_t size() const { return c.size(); }
    const_reference top() const { return c.front(); }
    void push(const value_type& x) {
        c.push_back(x);
        cpush_heap(c.begin(), c.end(), comp);

    }

    void pop() {
        cpop_heap(c.begin(), c.end(), comp);
        c.pop_back();
    }

};

#endif