//配列をヒープする void HeapSort(int A[], int n){ int i; int tmp; //ヒープを最下層の親から順に上に構築する for(i = n/2; i >= 0; i--){ DownHeap(A, i, n); } //ヒープの先頭から最大値を取り出し、昇順にソートする for(i = n; i >= 1; i--){ tmp = A[0]; A[0] = A[i]; A[i] = tmp; DownHeap(A, 0, i-1); } }
//配列aをヒープする void HeapSort(int a[], int n){ int i; int tmp; for(i = n/2; i >= 0; i--){ DownHeap(a, i, n); } for(i = n; i >= 1; i--){ tmp = a[0]; a[0] = a[i]; a[i] = tmp; DownHeap(a, 0, i-1); } }
UINT32 CEncoder::RemoveSmallest() { UINT32 aTop = m_Heap[kSmallest]; m_Heap[kSmallest] = m_Heap[m_HeapLength--]; DownHeap(kSmallest); return aTop; }
int make_tree(tPACK20* data, int nparm, unsigned int freqparm[], unsigned char lenparm[], unsigned int codeparm[]) { int i, j, k, avail; data->FreqTableSize = nparm; data->TreeFreq = freqparm; data->TreeLen = lenparm; avail = data->FreqTableSize; data->TreeHeapSize = 0; data->TreeHeap[1] = 0; for (i = 0; i < data->FreqTableSize; i++) { data->TreeLen[i] = 0; if (data->TreeFreq[i]) data->TreeHeap[++data->TreeHeapSize] = i; } if (data->TreeHeapSize < 2) { codeparm[data->TreeHeap[1]] = 0; return data->TreeHeap[1]; } for (i = data->TreeHeapSize/2; i>=1; i--) DownHeap(data,i); data->SortPtr = codeparm; do { i = data->TreeHeap[1]; if (i < data->FreqTableSize) *data->SortPtr++ = i; data->TreeHeap[1] = data->TreeHeap[data->TreeHeapSize--]; DownHeap(data,1); j = data->TreeHeap[1]; if (j < data->FreqTableSize) *data->SortPtr++ = j; k = avail++; data->TreeFreq[k] = data->TreeFreq[i] + data->TreeFreq[j]; data->TreeHeap[1] = k; DownHeap(data,1); data->Left[k] = i; data->Right[k] = j; } while (data->TreeHeapSize > 1); data->SortPtr = codeparm; MakeLen(data,k); MakeTreeCode(data,nparm, lenparm, codeparm); return k; }
void *RemoveHeapItem(struct FHeap *h) { void *ret=0; if (h->heap_n!=0) { ret=h->heap[1]; h->heap[1]=h->heap[h->heap_n]; h->heap_n--; DownHeap(1,h); } return ret; }
void CEncoder::BuildTree(BYTE *aLevels) { m_BlockBitLength = 0; int aMaxCode = -1; // WAS = -1; largest code with non zero frequency */ // Construct the initial m_Heap, with least frequent element in // m_Heap[kSmallest]. The sons of m_Heap[n] are m_Heap[2*n] and m_Heap[2*n+1]. // m_Heap[0] is not used. // m_HeapLength = 0; UINT32 n; // iterate over m_Heap elements for (n = 0; n < m_NumSymbols; n++) { if (m_Items[n].Freq != 0) { m_Heap[++m_HeapLength] = aMaxCode = n; m_Depth[n] = 0; } else m_Items[n].Len = 0; } // The pkzip format requires that at least one distance code exists, // and that at least one bit should be sent even if there is only one // possible code. So to avoid special checks later on we force at least // two codes of non zero frequency. while (m_HeapLength < 2) { int aNewNode = m_Heap[++m_HeapLength] = (aMaxCode < 2 ? ++aMaxCode : 0); m_Items[aNewNode].Freq = 1; m_Depth[aNewNode] = 0; m_BlockBitLength--; // if (stree) static_len -= stree[aNewNode].Len; // aNewNode is 0 or 1 so it does not have m_ExtraBits bits } // The elements m_Heap[m_HeapLength/2+1 .. m_HeapLength] are leaves of the m_Items, // establish sub-heaps of increasing lengths: for (n = m_HeapLength / 2; n >= 1; n--) DownHeap(n); // Construct the Huffman tree by repeatedly combining the least two // frequent nodes. int aNode = m_NumSymbols; // next internal node of the tree UINT32 aHeapMax = m_NumSymbols * 2+ 1; do { n = RemoveSmallest(); /* n = node of least frequency */ UINT32 m = m_Heap[kSmallest]; /* m = node of next least frequency */ m_Heap[--aHeapMax] = n; /* keep the nodes sorted by frequency */ m_Heap[--aHeapMax] = m; // Create a new node father of n and m m_Items[aNode].Freq = m_Items[n].Freq + m_Items[m].Freq; m_Depth[aNode] = (BYTE) (MyMax(m_Depth[n], m_Depth[m]) + 1); m_Items[n].Dad = m_Items[m].Dad = aNode; // and insert the new node in the m_Heap m_Heap[kSmallest] = aNode++; DownHeap(kSmallest); } while (m_HeapLength >= 2); m_Heap[--aHeapMax] = m_Heap[kSmallest]; // At this point, the fields freq and dad are set. We can now // generate the bit lengths. GenerateBitLen(aMaxCode, aHeapMax); // The field len is now set, we can generate the bit codes GenerateCodes (aMaxCode); for (n = 0; n < m_NumSymbols; n++) aLevels[n] = BYTE(m_Items[n].Len); }
int main () { int minHeapSize = 0; int maxHeapSize = 0; int minHeap[MAX_INPUT_NUM/2+1] = {0}; int maxHeap[MAX_INPUT_NUM/2+1] = {0}; int input = 0; while (scanf("%d", &input) == 1) { if (maxHeapSize == 0) { maxHeap[0] = input; maxHeapSize++; printf("%d\n", input); continue; } else { if (input <= maxHeap[0]) { maxHeap[maxHeapSize] = input; maxHeapSize++; UpHeap(maxHeap, maxHeapSize, CompareGreater); DownHeap(maxHeap, maxHeapSize, CompareLess); } else { minHeap[minHeapSize] = input; minHeapSize++; UpHeap(minHeap, minHeapSize, CompareLess); DownHeap(minHeap, minHeapSize, CompareGreater); } } if (maxHeapSize - minHeapSize == 2) { minHeap[minHeapSize] = maxHeap[0]; minHeapSize++; UpHeap(minHeap, minHeapSize, CompareLess); DownHeap(minHeap, minHeapSize, CompareGreater); maxHeap[0] = maxHeap[maxHeapSize-1]; maxHeapSize--; DownHeap(maxHeap, maxHeapSize, CompareLess); } if (minHeapSize - maxHeapSize == 2) { maxHeap[maxHeapSize] = minHeap[0]; maxHeapSize++; UpHeap(maxHeap, maxHeapSize, CompareGreater); DownHeap(maxHeap, maxHeapSize, CompareLess); minHeap[0] = minHeap[minHeapSize-1]; minHeapSize--; DownHeap(minHeap, minHeapSize, CompareGreater); } if (maxHeapSize == minHeapSize) { printf("%d\n", (maxHeap[0] + minHeap[0]) / 2); } else if (maxHeapSize > minHeapSize) { printf("%d\n", maxHeap[0]); } else { printf("%d\n", minHeap[0]); } } return 0; }
void FuncCodingFisherVector (float * data, float * coding, int * coding_bin, const CodingOpt * opt) { // codebook data const FisherVectorCodeBook * cb = &opt->fv_codebook; int nDim = cb->nDim, nBase = cb->nBase; const double * base = cb->base, *priors = cb->priors, * invSigma = cb->invSigma, * sqrtInvSigma = cb->sqrtInvSigma, * sumLogSigma = cb->sumLogSigma; // initialize for prob computation double probtemp = 0; int indi = 0; int heap_size = 1; double * prob_val = new double[opt->block_num]; int * prob_bin = new int[opt->block_num]; prob_val[0] = -1; // find high probability GMM for (int i=0; i<nBase; i++){ probtemp = sumLogSigma[i]; for (int k=0; k<nDim; k++) probtemp += ((double)data[k]-base[indi+k])*((double)data[k]-base[indi+k])*invSigma[indi+k]; probtemp *= -0.5; indi = indi+nDim; // a min-heap to keep max prob centers if(heap_size < opt->block_num) { UpHeap(prob_val, prob_bin, &heap_size, probtemp, i); } else if(probtemp > prob_val[0]) { DownHeap(prob_val, prob_bin, &heap_size); UpHeap(prob_val, prob_bin, &heap_size, probtemp, i); } } double probsum = 0; // normalize probs for (int i=0; i<opt->block_num; i++){ int bin = prob_bin[i]; prob_val[i] = exp(prob_val[i])*priors[bin]; probsum += prob_val[i]; } for (int i=0; i<opt->block_num; i++){ prob_val[i] /= probsum; // coding[i] = (float)prob_val[i]; } // coding vector for (int i=0; i<opt->block_num; i++){ int bin = prob_bin[i]; coding_bin[i] = bin; double sqrt_prior = cb->sqrtPrior[bin], sqrt_2_prior = cb->sqrt2Prior[bin]; for (int k=0; k<nDim; k++){ double diff = (data[k]-base[bin*nDim+k]); // temp = sign(temp)*MIN(maxsqrtSigma[i*nDim+k],fabs(temp)); #ifdef FIRST_ORDER coding[i*nDim+k] = (float)(prob_val[i]*diff*sqrtInvSigma[bin*nDim+k]/sqrt_prior); #else coding[i*nDim*2+k] = (float)(prob_val[i]*diff*sqrtInvSigma[bin*nDim+k]/sqrt_prior); coding[i*nDim*2+k+nDim] = (float)((prob_val[i]*diff*diff*invSigma[bin*nDim+k]-prob_val[i])/sqrt_2_prior); #endif } } delete [] prob_val; delete [] prob_bin; }