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

// Builds the tree
TreeNode<SymbolPriority>* MakeTree(const string& message)
{
	char										currentChar;
	vector<SymbolPriority>						temp;
	PriorityQueue<TreeNode<SymbolPriority>*>	myPriorityQueue;

	for (int i = 0; i < int(message.size()); i++)
	{
		currentChar = message[i];

		if ( temp.empty() )
			temp.push_back( SymbolPriority(currentChar, 1) );
		else if  ( characterExists(temp, currentChar) )
		{
			for (int c = 0; c < int (temp.size()); i++)
				if (currentChar == temp[i].Symbol)
					temp[i].Priority++;
		}
		else
			temp.push_back( SymbolPriority(currentChar, 1) );
	}


	for (int i = 0; i < int(temp.size()); i++)
	{
		if (myPriorityQueue.GetSize() <= 1)
			myPriorityQueue.Push( new TreeNode<SymbolPriority>( temp[i]) );

		else
		{
			char aChar; 
			TreeNode<SymbolPriority>* tempNode;
			// create a new TreeNode<SymbolPriority>* and
			// make the first popped element its left child
			// make the second popped element its right child
			// set its value to the sum of its left and right child priorities

			tempNode->Left = myPriorityQueue.Top();
			aChar = myPriorityQueue.Top()->Data.Priority;
			myPriorityQueue.Pop();

			tempNode->Right = myPriorityQueue.Top(); 
			aChar += myPriorityQueue.Top()->Data.Priority;
			myPriorityQueue.Pop();

			myPriorityQueue.Push( tempNode );
		}
	}

	return myPriorityQueue.Top();
}

void bestFirstSearch(state_t *state) {

    PriorityQueue<state_t> pq;
    pq.Add(0,0,*state);

    state_map_t *map = new_state_map();
    state_map_add(map,state,0);

    state_t currentState;
    state_t child;

    int *cost;
    int ruleid, priority, childCost;
    ruleid_iterator_t iter;

    while (!pq.Empty()) {

        priority = pq.CurrentPriority();

        currentState = pq.Top();
        pq.Pop();    

        nodes++;       

        cost = state_map_get(map,&currentState);

        if (cost == nullptr || priority <= *cost) {

            /* The state added to map is Gray */
            state_map_add(map,&currentState,priority);

            if (is_goal(&currentState)) {
               
                fprintf(output, ": - %i %lu ", priority, nodes);
                destroy_state_map(map);
                return;
            }           

            init_fwd_iter(&iter,&currentState);

            while((ruleid = next_ruleid(&iter)) >= 0) {

                apply_fwd_rule(ruleid,&currentState,&child);

                if (h.getHeuristic(&child) < UINT_MAX) {                
                    childCost = priority + get_fwd_rule_cost(ruleid);
                    state_map_add(map,&child,childCost);
                    pq.Add(childCost,childCost,child);
                }
            }           
        }
    }
    destroy_state_map(map);
    cout << "No goal found.\n";
}

        bool Prim(SGraph& graph, SGraph& result){
            SGraph t_g = graph;
            int num_v = graph.GetNumVertices();

            result.Clear();
            if(!graph.IsConnected()){
                return false;
            }

            Vector<SGraph::Edge> unroll_edges;
            graph.UnrollEdges(unroll_edges);
            Algorithms::Sorting::HeapSort(unroll_edges, unroll_edges);

            PriorityQueue<SGraph::Edge> adjacencies;
            Vector<int> v_adjac;

            SGraph::Edge e = unroll_edges[0];
            SGraph::Edge t(0,0);

            t_g.DeleteEdge(e);
            result.AddEdge(e);

            while(result.GetNumEdges() < (num_v -1)){
                t_g.FindAdjacencyVertices(e.head, v_adjac);
                for(int i = 0; i < v_adjac.Size(); i++){
                    if(result.HasVertex(v_adjac[i])) continue;
                    t.head = e.head;
                    t.tail = v_adjac[i];
                    t.weight = t_g.GetEdgeW(t.head, t.tail);
                    adjacencies.Push(t);
                }

                t_g.FindAdjacencyVertices(e.tail, v_adjac);
                for(int i = 0; i < v_adjac.Size(); i++){
                    if(result.HasVertex(v_adjac[i])) continue;
                    t.head = v_adjac[i];
                    t.tail = e.tail;
                    t.weight = t_g.GetEdgeW(t.head, t.tail);
                    adjacencies.Push(t);
                }

                e = adjacencies.Head();
                result.AddEdge(e);
                t_g.DeleteEdge(e);
                adjacencies.Pop();
            }

            return true;
        }

int main( int argc, char **argv )
{
    // VARIABLES FOR INPUT
    char str[ MAX_LINE_LENGTH +1 ] ;
    ssize_t nchars; 
    state_t state; // state_t is defined by the PSVN API. It is the type used for individual states.

    PriorityQueue<state_t> open;
    //state_map_t *map = new_state_map();//******
    // VARIABLES FOR ITERATING THROUGH state's SUCCESSORS
    state_t child;
    ruleid_iterator_t iter; // ruleid_terator_t is the type defined by the PSVN API successor/predecessor iterators.
    int ruleid ; // an iterator returns a number identifying a rule
    int64_t totalNodes;

    // READ A LINE OF INPUT FROM stdin
    printf("Please enter a state followed by ENTER: ");
    if ( fgets(str, sizeof str, stdin) == NULL ) {
        printf("Error: empty input line.\n");
        return 0; 
    }

    // CONVERT THE STRING TO A STATE
    nchars = read_state( str, &state );
    if (nchars <= 0) {
        printf("Error: invalid state entered.\n");
        return 0; 
    }

    printf("The state you entered is: ");
    print_state( stdout, &state );
    printf("\n");

    List StateList = List(); 
   // state_map_add( map, &state, 0 );//******dont know if its a must
    open.Add(0,0,state);
    StateList.add(&state);
    StateList.change_color(&state,1);// Gray
   // StateList.change_distance(&state,0);

    totalNodes = 0;
    int d = 0;
    /* Search */
    while ( !open.Empty() ) {

        // g.n
        d = open.CurrentPriority();
printf("D: %d\n",d);
        state = open.Top();
        open.Pop();

        totalNodes++;

        /* DDD */
        if (StateList.get_color(&state)==0 || (StateList.get_distance(&state)>(d-1))){
            StateList.change_distance(&state,d);
            if (is_goal(&state)==1){
                //PRINT STUFF
                printf("Estado: ");
                print_state( stdout, &state);
                printf(" Estados Generados: %"PRId64" , costo: %d",totalNodes,StateList.get_distance(&state));
                return 1;//SUCCES
            }

            /* expand node */
            init_fwd_iter(&iter, &state);
            while((ruleid = next_ruleid(&iter)) >= 0){
                apply_fwd_rule(ruleid,&state,&child);//'child' is a succesor state_t of 'state'
                StateList.add(&child);
                StateList.change_color(&child, 1);//Gray
                const int child_d = d + get_fwd_rule_cost(ruleid);
                StateList.change_distance( &child , child_d );
                open.Add( child_d , child_d , child );
            }
            StateList.change_color(&state,2); //Black
        }

    }
    printf("FAIL!");
    return 2; //FAIL
}

int main(int argc, char **argv)
{
	// using PriorityQueue = pg::heap::Binary<int>;
	using PriorityQueue = pg::heap::Pairing<int>;
	// using PriorityQueue = StdWrapper<int>;

	test("Basic Push/Pop", []()
	{
		PriorityQueue pq;

		pq.Push(10);
		pq.Push(5);
		pq.Push(8);
		pq.Push(12);
		pq.Push(1);
		pq.Push(90);
		pq.Push(9);

		assertEquals(1, pq.Pop());
		assertEquals(5, pq.Pop());
		assertEquals(8, pq.Pop());
		assertEquals(9, pq.Pop());
		assertEquals(10, pq.Pop());
		assertEquals(12, pq.Pop());
		assertEquals(90, pq.Pop());
		assertEquals(true, pq.Empty());
	});

	test("Update value", []()
	{
		PriorityQueue pq;

		pq.Push(10);
		pq.Push(5);
		pq.Push(8);
		pq.Push(12);
		pq.Push(1);
		pq.Push(90);
		pq.Push(9);

		pq.Update(70, 5);
		pq.Update(7, 12);

		assertEquals(1, pq.Pop());
		assertEquals(7, pq.Pop());
		assertEquals(8, pq.Pop());
		assertEquals(9, pq.Pop());
		assertEquals(10, pq.Pop());
		assertEquals(70, pq.Pop());
		assertEquals(90, pq.Pop());
		assertEquals(true, pq.Empty());
	});

	test("Performance", []()
	{
		constexpr auto size = 1000000;
		std::default_random_engine random_engine(time(nullptr));
		std::uniform_int_distribution<int> distribution(1,9999999);
		auto rand = std::bind ( distribution, random_engine );

		std::vector<int> test;
		PriorityQueue pq;

		for(int i = 0 ; i < size; i++)
			pq.Push(rand());

		while(!pq.Empty())
			test.push_back(pq.Pop());

		assertEquals(true, std::is_sorted(test.begin(), test.end()));
	});

	return 0;
}