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

	HuffmanTree(const T *a, size_t n)
	{
		struct NodeCompare
		{
			bool operator() (const Node *left, const Node *right)
			{
				return (left->_weight) <( right->_weight);
			}
		};

		Heap<Node*, NodeCompare> minHeap;

		for (size_t i = 0; i < n; ++i)
		{
			minHeap.Push(new Node(a[i]));
		}

		while (minHeap.Size() > 1)
		{
			Node *left = minHeap.Top();
			minHeap.Pop();
			Node *right = minHeap.Top();
			minHeap.Pop();

			Node *parent = new Node(left->_weight + right->_weight);
			parent->_left = left;
			parent->_right = right;

			minHeap.Push(parent);
		}

		_root = minHeap.Top();
	}

	Node* CreateTree(const T*a, size_t size, const T&invalid)
	{
		Heap<Node*, Less<Node*>> minHeap;

		for (size_t i = 0; i < size; ++i)
		{
			if (a[i] != invalid)
			{
				Node* tmp = new Node(a[i]);
				minHeap.Push(tmp);
			}
		}

		while (!minHeap.empty())
		{
			Node* left = minHeap.Top();
			minHeap.Pop();
			Node* right = NULL;

			if (!minHeap.empty())
			{
				right = minHeap.Top();
				minHeap.Pop();
			}

			Node* parent = NULL;

			if (right)
			{
				parent = new Node(left->_weight + right->_weight);
			}
			else
			{
				parent = new Node(left->_weight);
			}

			parent->_left = left;
			parent->_right = right;

			if (minHeap.empty())
			{
				return parent;
			}

			minHeap.Push(parent);
		}

		return NULL;
	}

// 测试堆
void TestHeap()
{
	Heap<int, greater<int>> heap;
	heap.Push(3);
	heap.Push(5);
	heap.Push(1);
	heap.Push(4);
	heap.Push(5);
	heap.Push(1);
	heap.Push(8);

	while (!heap.Empty())
	{
		cout<<heap.Top()<<" ";
		heap.Pop();
	}
	cout<<endl;

	//int array[10] = {9,1,3,5,6,7,8,0,2,4};
	int array[10] = {10,16,18,12,11,13,15,17,14,19};
	Heap<int> heap1(array, 10);

	while (!heap1.Empty())
	{
		cout<<heap1.Top()<<" ";
		heap1.Pop();
	}
	cout<<endl;
}

int main(void){
    srand(time(NULL));
    Heap oneHeap;
    HeapElement elem;
    const unsigned SIZE = 10;
    std::cout << "Input data: ";
    for(unsigned i = 0; i < SIZE; i++){
        elem.key = rand();
        oneHeap.Add(elem);
        std::cout << elem.key << ' ';
    }

    std::cout << "\nOutput data: ";
    for (unsigned i = 0; i< SIZE; i++)
        std::cout << oneHeap.Pop().key << ' ';

}

void RollModel::Roll(int min, int max, int times)
{
    struct occurrence_t{
        int value;
        uint count;
        bool operator < (const occurrence_t &o) const{
            return count > o.count ||
                    (count == o.count && value < o.value);
        }
    };

    beginResetModel();
    m_data.resize(times);
    m_total = 0;
    m_min = GINT32_MAX;
    m_max = GINT32_MIN;
    m_mode.clear();
    m_modeCount = 0;
    m_mean = 0.0;
    m_median = 0.0;
    QHash<int, uint> occurrences;

    for(int i = 0; i < times; i++){
        int X = m_rng.U_Discrete(min, max);
        m_data[i] = X;
        m_total += X;

        if(X < m_min)
            m_min = X;
        if(X > m_max)
            m_max = X;

        if(occurrences.contains(X))
            occurrences[X]++;
        else
            occurrences.insert(X, 1);
    }
    m_mean = (double)m_total/times;
    
    // Compute the median
    vector<int> sorted_data = m_data;
    std::sort(sorted_data.begin(), sorted_data.end());
    int median_index = sorted_data.size() / 2;
    int val1 = sorted_data[median_index];
    int val2 = (sorted_data.size() & 1) ? val1 : sorted_data[median_index - 1];
    m_median = ((double)val1 + val2) / 2;

    // Compute the mode (using heap sort)
    Heap<occurrence_t> heap;
    for(int k : occurrences.keys())
        heap.Push({k, occurrences[k]});

    if(heap.Count()){
        occurrence_t *t = heap.Top();
        uint mode_count = t->count;
        int cnt = 0;
        vector<int> tmp_mode;
        while(t && (mode_count == t->count)){
            tmp_mode.push_back(t->value);
            heap.Pop();
            t = heap.Top();
            cnt++;
        }

        // If every item is the mode, then there is no mode
        if(cnt < occurrences.keys().count()){
            m_modeCount = mode_count;
            m_mode = tmp_mode;
        }
    }
    endResetModel();
}

std::vector<Aresta *> Grafo::Kruskal() {
	std::vector<Aresta *> retorno;
	//so faz se nao eh direcionado
	if (!this->Direcionado()) {
		//conjunto de vertices e ranks
		std::vector<int> ranks;
		//inicializa conjunto de vertices e ranks
		Heap * nHeap;
		int tamHeapMax = 0;
		conjKruskal.clear();
		ranks.clear();
		for (int i = 0; i < tamGrafo; i++) {
			this->conjKruskal.push_back(i);
			ranks.push_back(1);
			for (int j =0; j < tamGrafo; j++)
				if (this->Conexao(i,j))
					tamHeapMax++;
		}
		nHeap = new Heap(tamHeapMax);
		nHeap->SetTipo(MINIMO);
		for (int i = 0; i < tamGrafo; i++) {
			for (int j =i; j < tamGrafo; j++) {
				if (this->Conexao(i,j)) {
					Aresta * nAresta = new Aresta(*this->GetVertice(i).GetAresta(j));
					nHeap->Push(nAresta);
				}
			}
		}
		
		//nHeap->ListaHeap();
		int id1;
		int id2;
		int id1tmp;
		int id2tmp;

		std::vector<Aresta *> lArestas;

		while(nHeap->GetTamHeap() > 0 ) {
			Aresta * cAresta = nHeap->Pop();
			id1 = cAresta->GetId1();
			id2 = cAresta->GetId2();
			//cout << "id1: " << id1 << " id2:" << id2 << endl;
			
			if ((id1tmp = this->BuscaKruskal(id1)) != (id2tmp = BuscaKruskal(id2))) {
				//cout << "conjuntos diferentes: " << "id1: " << this->BuscaKruskal(id1) << " id2: " << this->BuscaKruskal(id2) << endl;
				retorno.push_back(cAresta);
				if (ranks[id1tmp] != ranks[id2tmp]) {
					int maior = (ranks[id1tmp] > ranks[id2tmp] ? id1tmp : id2tmp);
					int menor = (ranks[id2tmp] > ranks[id1tmp] ? id1tmp : id2tmp);
					conjKruskal[menor] = maior;
					//cout << "ranks: " << " menor: " << ranks[menor] << "maior: " << ranks[maior] << endl;
				} else {
					conjKruskal[id2tmp] = id1tmp;
					ranks[id1tmp] += 1;
					//cout << "aumentou rank" << endl;
				}
			}
		}
	}
	
	return retorno;
}