C++ PriorityQueue::pop方法代码示例

int main()
{
    // push , pop , top test
    {
        PriorityQueue<int> p;
        assert(p.getSize() == 0);
        assert(p.getCapacity() == 21);

        p.push(3);p.push(2);p.push(7);p.push(11);p.push(23);
        p.pop();p.pop();
        p.push(3);p.push(2);p.push(43);p.push(21);p.push(25);
        p.pop();p.pop();
        vector<int> vcmp = {7, 11, 21, 23, 25, 43};

        assert(p.getSize() == 6);
        assert( vcmp == print_queue<int>(p));
        assert(p.getCapacity() == 21);

    }

    // size , capacity , clear , destroy test
    {
        PriorityQueue<int> p;
        assert(p.getSize() == 0);
        assert(p.getCapacity() == 21);

        for(auto i = 0; i<21; i++){
            p.push(i);
        }
        assert(p.getSize() == 21);
        assert(p.getCapacity() == 42);

        p.clear();
        assert(p.getSize() == 0);
        assert(p.getCapacity() == 42);

        p.destroy();
        assert(p.getSize() == 0);
        assert(p.getCapacity() == 0);
    }

    // heapsort test
    {
        vector<int> v = {1, 16, 12, 2, 25, 5, 6};
        vector<int> cmpv = {1, 2, 5, 6, 12, 16, 25};
        heap_sort(v.begin(), v.end());
        assert(v == cmpv);
        
    }


    cout<< "All TestCases Pass."<<endl;
    return 0;
}

void PriorityQueueTest::testThreadFill( void )
{
  CPPUNIT_ASSERT( _queue->empty() );

  ClassFuncThread<PriorityQueueTest> fillQueueThread( this, &PriorityQueueTest::fillQueue );
  CPPUNIT_ASSERT_NO_THROW( fillQueueThread.start() );

  for ( unsigned i = 0; i < FillSize; ++i ) {
    Dummy::Ptr d( _dummies->pop() );
    CPPUNIT_ASSERT( d );
    CPPUNIT_ASSERT( d->isValid() );

    Dummyer::Ptr d2( d );
    CPPUNIT_ASSERT( d2 );
    CPPUNIT_ASSERT( d2->isValid() );

    CPPUNIT_ASSERT( d->refs() );
    CPPUNIT_ASSERT_EQUAL( i, d->val() );
    d = 0;
    d2 = 0;
  }

  CPPUNIT_ASSERT_NO_THROW( fillQueueThread.join() );
  CPPUNIT_ASSERT( _queue->empty() );
}

void PriorityQueueTest::testOrder( void )
{
  _queue->push( 5, 0.0 );
  _queue->push( 6, 0.0 );
  _queue->push( 3, 1.0 );
  _queue->push( 4, 1.0 );
  _queue->push( 1, 2.0 );
  _queue->push( 2, 2.0 );

  CPPUNIT_ASSERT_EQUAL( 1U, _queue->pop() );
  CPPUNIT_ASSERT_EQUAL( 2U, _queue->pop() );
  CPPUNIT_ASSERT_EQUAL( 3U, _queue->pop() );
  CPPUNIT_ASSERT_EQUAL( 4U, _queue->pop() );
  CPPUNIT_ASSERT_EQUAL( 5U, _queue->pop() );
  CPPUNIT_ASSERT_EQUAL( 6U, _queue->pop() );
}

// @snip <sh19910711/contest:setlib/disjoints_set.cpp>
template <typename GraphType> const typename std::vector<typename GraphType::Edge> get_minimum_spanning_forest( const GraphType& G ) {
  typedef typename std::vector<typename GraphType::Edge> Edges;
  typedef typename GraphType::Edge GraphEdge;
  typedef typename GraphType::Edges GraphEdges;
  typedef std::priority_queue<GraphEdge, Edges, std::greater<GraphEdge> > PriorityQueue;
  typedef setlib::DisjointSets UnionFind;

  Edges res;
  PriorityQueue E;
  UnionFind uf(G.num_vertices);

  for ( int i = 0; i < G.num_vertices; ++ i ) {
    for ( typename GraphEdges::const_iterator it_i = G.vertex_edges[i].begin(); it_i != G.vertex_edges[i].end(); ++ it_i ) {
      const GraphEdge& e = **it_i;
      E.push(GraphEdge(e.from, e.to, e.weight));
    }
  }

  while ( ! E.empty() ) {
    GraphEdge e = E.top();
    E.pop();
    if ( ! uf.same(e.from, e.to) ) {
      res.push_back(e);
      uf.merge(e.from, e.to);
    }
  }

  return res;
}

vector<T> print_queue(PriorityQueue<T> &q){
    vector<T> ret;
    while(!q.isEmpty()) {
        ret.push_back(q.getTop());
        q.pop();
    }
    return ret;
}

void PriorityQueueTest::squareQueue( void )
{
  for ( unsigned i = 0; i < FillSize; ++i ) {
    unsigned v;
    CPPUNIT_ASSERT_NO_THROW( v = _queue->pop() );
    CPPUNIT_ASSERT_NO_THROW( _squared->push( sqr(v) ) );
  }
}

void PriorityQueueTest::testPush( void )
{
  CPPUNIT_ASSERT( _queue->empty() );
  CPPUNIT_ASSERT_NO_THROW( _queue->push( 42 ) );
  CPPUNIT_ASSERT_EQUAL( 1U, _queue->size() );
  CPPUNIT_ASSERT_EQUAL( 42U, _queue->pop() );
  CPPUNIT_ASSERT( _queue->empty() );
}

void dumpContents( const string & msg, PriorityQueue & pq )
{
    cout << msg << ":" << endl;
    while( !pq.empty( ) )
    {
        cout << pq.top( ) << endl;
        pq.pop( );
    }
}

int main(){
  PriorityQueue<int> pq;
  for(int i=0;i<10;i++){
    pq.push(i);
  }
  while(!pq.empty()){
    cout<<pq.top()<<" ";
    pq.pop();
  }
}

float* Dijkstra::dijkstra(Graph *&graph, int s)
{
	int n = graph->getVerticesNum();
	if ((s < 0)||(s >= n))
		return 0;
	int m = graph->getRealSize();
	
	Data** dist = new Data*[n];
	int* up = new int[n];

	for (int i = 0; i < n; i++){
		up[i] = 0;
		dist[i] = new DataFloat(i, FLT_MAX);
	}
	dist[s]->priority = 0;

	PriorityQueue *queue = new PriorityQueue(dist, n, 4);

	Edge** edges = graph->getEdgeSet();
	int edgeCount = m;
	while ((edgeCount != 0) && (!queue->isEmpty()))
	{
		Data* tmp = queue->pop();
		int v = ((DataFloat*)tmp)->v;
		int v0 = -1;
		float delta;
		for (int i = 0; i < m; i++)
		{
			v0 = -1;
			if (edges[i]->K == v)
				v0 = edges[i]->N;
			if (edges[i]->N == v)
				v0 = edges[i]->K;
			if (v0 == -1) continue;
			//edgeCount--;
			delta = dist[v0]->priorities - (dist[v]->priorities + graph->getWeight(v, v0));
			if (delta > 0){
				dist[v0]->priorities = graph->getWeight(v, v0) + dist[v]->priorities;
				up[v0] = v;
			}
		}
	}
	
	float *result = new float[n];
	for (int i = 0; i < n; i++)
		result[i] = dist[i]->priorities;

	for (int i = 0; i < n; i++)
		delete dist[i];
	delete []dist;
	delete queue;
	delete []up;

	return result;
}

void PriorityQueueTest::testSynchronize( void )
{
  ClassFuncThread<PriorityQueueTest> enqueueThread( this, &PriorityQueueTest::enqueue );
  CPPUNIT_ASSERT_NO_THROW( enqueueThread.start() );

  unsigned v;
  CPPUNIT_ASSERT_NO_THROW( v = _queue->pop() );
  CPPUNIT_ASSERT_EQUAL( 42U, v );

  CPPUNIT_ASSERT_NO_THROW( enqueueThread.join() );
  CPPUNIT_ASSERT( _queue->empty() );
}

int main()
{

  PriorityQueue* pq = new PriorityQueue;
  
  pq->push(7);
  pq->push(3);
  pq->push(10);
  pq->push(1);

   

  cout << pq->pop() << endl;
  cout << pq->pop() << endl;
  cout << pq->pop() << endl;
  cout << pq->pop() << endl;


  delete pq;   

  return 0;
}

inline
void inpainting_loop(VertexListGraph& g, InpaintingVisitorType vis,
                      BoundaryStatusMap& boundaryStatusMap, PriorityQueue& boundaryNodeQueue,
                      NearestNeighborFinder find_inpainting_source, 
                      PatchInpainter inpaint_patch) 
{
  typedef typename boost::graph_traits<VertexListGraph>::vertex_descriptor Vertex;
  typedef typename boost::graph_traits<VertexListGraph>::edge_descriptor Edge;
  typedef typename boost::property_traits<PositionMap>::value_type PositionValueType;
  
  // When this function is called, the priority-queue should already be filled 
  // with all the hole-vertices (which should also have "Color::black()" color value).
  // So, the only thing this function does is run the inpainting loop. All of the
  // actual code is externalized in the functors and visitors (vis, find_inpainting_source, inpaint_patches, etc.).

  while(true) 
  {
    // find the next target to in-paint:
    Vertex targetNode;
    do
    {
      if( boundaryNodeQueue.empty() )
      {
        std::cout << "Queue is empty, exiting." << std::endl;
        return;  //terminate if the queue is empty.
      }
      targetNode = boundaryNodeQueue.top();
      boundaryNodeQueue.pop();
    } while( get(boundaryStatusMap, targetNode) == false );

    // Notify the visitor that we have a hole target center.
    vis.discover_vertex(targetNode, g);

    // next, we want to find a source patch-center that matches best to our target-patch:
    Vertex source_patch_center = find_inpainting_source(targetNode);
    vis.vertex_match_made(targetNode, source_patch_center, g);

    // finally, do the in-painting of the target patch from the source patch.
    //  the inpaint_patch functor should take care of iterating through the vertices in both
    //  patches and call "vis.paint_vertex(target, source, g)" on the individual vertices.
    inpaint_patch(targetNode, source_patch_center, g, vis);

    if(!vis.accept_painted_vertex(targetNode, g))
      {
      throw std::runtime_error("Vertex was not painted successfully!");
      }

    vis.finish_vertex(targetNode, g);
  } // end main iteration loop
  
};

void heap_sort(T &begin, T &end) {
    PriorityQueue<int> p;
    T it = begin;
    while(it!=end) {
        p.push(*it);
        it++;
    }
    it = begin;
    while(it!=end) {
        *it = p.getTop();
        p.pop();
        it++;
    }
}

	Node getNode(char name){
		if (find(name)){
			PriorityQueue tempQueue;
			while (top().name != name){
				tempQueue.push(top());
				pop();
			}
			Node node = top();
			while (!tempQueue.empty()){
				push(tempQueue.top());
				tempQueue.pop();
			}
			return node;
		}
	}