void heapsort(PPD &ppd,PPI &ppi,VArrayL &ndx,ulong left,ulong right, BOOL b) { // heapsort by prices long perc=0, oldperc=0; // percentage done // creating a heap... for (long k=(right-left+1)/2+left;k>=(long)left; k--) { // left-1 ?! siftdown(ppd,ppi,ndx,left,right,k,b); perc = (1-(float)(k-left)/((right-left)/2))*50; if (perc>oldperc) { cout.width(3); cout << (oldperc=perc) << '%' << "\x8\x8\x8\x8"; } } // heap created. Now sorting... for (k=right; k>left; ) { swap(ndx,left,k); siftdown(ppd,ppi,ndx,left,--k,left,b); perc=(2-(float)(k-left)/(right-left))*50; if (perc>oldperc) { cout.width(3); cout << (oldperc=perc) << '%' << "\x8\x8\x8\x8"; } } cout << (right-left+1) << " elements done.\n"; }
static void timerproc ( void ) { int64 delta , now; Timer *t; void ( *f ) ( int64 , Eface ) ; Eface arg; #line 198 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" for ( ;; ) { runtime·lock ( &timers ) ; timers.sleeping = false; now = runtime·nanotime ( ) ; for ( ;; ) { if ( timers.len == 0 ) { delta = -1; break; } t = timers.t[0]; delta = t->when - now; if ( delta > 0 ) break; if ( t->period > 0 ) { #line 213 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" t->when += t->period * ( 1 + -delta/t->period ) ; siftdown ( 0 ) ; } else { #line 217 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" timers.t[0] = timers.t[--timers.len]; timers.t[0]->i = 0; siftdown ( 0 ) ; t->i = -1; } f = ( void* ) t->fv->fn; arg = t->arg; runtime·unlock ( &timers ) ; if ( raceenabled ) runtime·raceacquire ( t ) ; f ( now , arg ) ; #line 230 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" f = nil; USED ( f ) ; arg.type = nil; arg.data = nil; USED ( &arg ) ; #line 236 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" runtime·lock ( &timers ) ; } if ( delta < 0 ) { #line 240 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" timers.rescheduling = true; runtime·parkunlock ( &timers , "timer goroutine (idle)" ) ; continue; } #line 245 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" timers.sleeping = true; runtime·noteclear ( &timers.waitnote ) ; runtime·unlock ( &timers ) ; runtime·notetsleepg ( &timers.waitnote , delta ) ; } }
void heapsort (KEY_T array[], int len) { register int i; register KEY_T temp, *sa = array - 1; /* | 'sa[]' is 'array[]' "shifted" one position to the left | i.e. sa[i] == array[i - 1] (in particular: sa[1] == array[0]) | 'sa' has "Pascalish" indices and is thus more convenient | for heap-sorting. An index i obeys the law: | left_child (i) == 2i, right_child (i) == 2i + 1 | Note: we don't use a[-1] which is outside our range, we just | fake an array that starts one address lower, so we can refer | to its first element as a[1] (rather than as a[0]) */ /* first step: make 'sa[]' a heap using siftdown len/2 times */ for (i = len / 2; i >= 1; i--) siftdown (sa, i, len); /* heapify N more times, to reach complete order */ for (i = len; i >= 2; i--) { SWAP(sa[1], sa[i]); siftdown (sa, 1, i - 1); } }
void hsort(DType x[], int n) { int i; x--;//注意这里 for (i = n/2; i >= 1; i--) siftdown(x, i, n); for (i = n; i >= 2; i--) { swap(x, 1, i); siftdown(x, 1, i-1); } x++;//注意这里 }
void *cp_heap_pop(cp_heap *h) { int rc; void *retval = NULL; if (h == NULL) return NULL; if ((rc = cp_heap_txlock(h))) return NULL; if (h->heap != NULL && h->heap_end > 1) { retval = h->heap[1]; #ifdef _HEAP_TRACE DEBUGMSG("cp_heap_pop: %p\n", retval); #endif if ((h->mode & COLLECTION_MODE_DEEP) && h->dtr) (*h->dtr)(retval); h->heap[1] = h->heap[h->heap_end - 1]; h->heap_end--; siftdown(h, 1); } cp_heap_txunlock(h); return retval; }
bool runtime·deltimer ( Timer *t ) { int32 i; #line 156 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" i = t->i; USED ( i ) ; #line 159 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" runtime·lock ( &timers ) ; #line 164 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" i = t->i; if ( i < 0 || i >= timers.len || timers.t[i] != t ) { runtime·unlock ( &timers ) ; return false; } #line 170 "/home/14/ren/source/golang/go/src/pkg/runtime/time.goc" timers.len--; if ( i == timers.len ) { timers.t[i] = nil; } else { timers.t[i] = timers.t[timers.len]; timers.t[timers.len] = nil; timers.t[i]->i = i; siftup ( i ) ; siftdown ( i ) ; } if ( debug ) dumptimers ( "deltimer" ) ; runtime·unlock ( &timers ) ; return true; }
// Heapinsert inserts x into heap h according to h->less. // It returns 1 on success, otherwise 0. int heapinsert(Heap *h, void *x) { int k; if (h->len == h->cap) { void **ndata; int ncap = (h->len+1) * 2; /* allocate twice what we need */ ndata = malloc(sizeof(void*) * ncap); if (!ndata) { return 0; } memcpy(ndata, h->data, sizeof(void*)*h->len); free(h->data); h->data = ndata; h->cap = ncap; } k = h->len; h->len++; set(h, k, x); siftdown(h, k); return 1; }
void dheap::remove(item i) { // Remove item i from heap. Name remove is used since delete is C++ keyword. int j = h[n--]; if (i != j && kvec[j] <= kvec[i]) siftup(j,pos[i]); else if (i != j && kvec[j] > kvec[i]) siftdown(j,pos[i]); pos[i] = Null; }
static status siftdown (heap * const p_H, size_t const index) { size_t const left_child_index = first_child_index(index); if (left_child_index >= p_H -> next_element) return OK; { size_t right_child_index = left_child_index + 1; /*select the index of the child that is candidate for swapping */ size_t cmp_target_index = right_child_index == p_H -> next_element ? left_child_index : (*(p_H -> p_cmp_f))(p_H -> base[left_child_index], p_H -> base[right_child_index]) > 0? right_child_index : left_child_index; if ((*(p_H -> p_cmp_f))(p_H -> base[index], p_H -> base[cmp_target_index]) > 0) { swap(p_H, index, cmp_target_index); return siftdown(p_H, cmp_target_index); }//if }//scope return OK; }//siftdown
static int siftup(struct heap *h, size_t pos) { assert(pos < ptrvec_size(h->vec)); void *newitem = ptrvec_value(h->vec, pos); size_t endpos = ptrvec_size(h->vec); size_t startpos = pos; size_t childpos = 2 * pos + 1; while (childpos < endpos) { size_t rightpos = childpos + 1; if (rightpos < endpos) { int cmp = cmp_wrapper(h->cmp, ptrvec_value(h->vec, childpos), ptrvec_value(h->vec, rightpos)); if (cmp == -1) return (-1); if (cmp == 0) childpos = rightpos; } ptrvec_data(h->vec)[pos] = ptrvec_value(h->vec, childpos); pos = childpos; childpos = 2 * pos + 1; } ptrvec_data(h->vec)[pos] = newitem; return (siftdown(h, startpos, pos)); }
void test005() { int arr[] = {2, 9, 1, 5, 4, 3}; int i = 0; for(i=0;i<5;i++) { printf("%d ", arr[i]); } printf("%d\n", arr[i]); quickSort(arr, 6); for(i=0;i<5;i++) { printf("%d ", arr[i]); } printf("%d\n", arr[i]); siftdown(arr, 1, 6); for(i=0;i<5;i++) { printf("%d ", arr[i]); } printf("%d\n", arr[i]); siftup(arr , 2, 6); for(i=0;i<5;i++) { printf("%d ", arr[i]); } printf("%d\n", arr[i]); }
/* * Function: void *bh_pop( Bh *h ) * Description: delete the root element and return it * Input: h: the bh object * Output: none * Return: void*: the root element * Others: none */ void *bh_pop( Bh *h ) { int rc; void *retval = NULL; if( h == NULL ) { return NULL; } bh_info( h ); if( h->heap != NULL && h->heap_end >= 1 ) { retval = h->heap[1]; if( h->dtr ) { ( *h->dtr )( retval ); } h->heap[1] = h->heap[h->heap_end]; // root points to the last node h->heap_end--; siftdown( h, 1 ); } return retval; }
void Heap::remove_top() { if (p == 0) return; root[0] = root[--p]; if (p != 0) siftdown(0); }
void Heap::remove(int oldval) { int i=p[oldval]; a[i]=a[h--]; p[a[i]]=i; siftdown(i); siftup(i); }
void creat() { int i; for(i=n/2;i>=1;i--) { siftdown(i); } }
static void flashpage_heapsort(void) { short i; unsigned short** lines = lineindexstart; unsigned short count = lineindexend - lineindexstart; for (i = count / 2; i >= 0; i--) { siftdown(i, count - 1); } for (i = count - 1; i >= 0; i--) { unsigned short* temp = lines[0]; lines[0] = lines[i]; lines[i] = temp; siftdown(0, i - 1); } }
int deletemax() { int t; t=h[1]; h[1]=h[n]; n--; siftdown(1); return t; }
void heapsort(void** arr, int size, int(*comp)(void*,void*)){ mkheap(arr,size,comp); int end = size-1; while(end>0){ swap(&arr[end],&arr[0]); end--; siftdown(arr,0,end,comp); } }
vertex* pq_remove(pqueue* pq) { if( pq->n == 0 ) return NULL; pq->n--; swap(0, pq->n, pq); if (pq->n != 0) /* Not on last element */ siftdown(0, pq); /* Put new heap root val in correct place */ return pq->elems[pq->n]; }
/*======================================================================\ * Author (作者): i.sshe * Date (日期): 2016/03/27 * Others (其他): \*=======================================================================*/ void create_min_heap(int *heap_array, int len) { int i = len/2; //最后一个页节点的父节点. for (; i > 0; i--) //不能=0! { siftdown(heap_array, i, len); } }
void heapify(Tree** heap, int n) { for(int i = (n - 2) / 2; i >= 0; i--) { siftdown(heap, n, i); } // printf("After Heapify: "); // for(int i = 0; i<n; i++) { // printf("%c ", heap[i]->key); // } // printf("\n"); }
Tree* heapDelete(Tree** heap, int n) { Tree* temp = heap[0]; heap[0] = heap[n-1]; heap[n-1] = temp; siftdown(heap, n-1, 0); // printf("After Delete: "); // for(int i = 0; i<n; i++) { // printf("%c ", heap[i]->key); // } // printf("\n"); return heap[n-1]; }
int rmmin_heap(struct heap *p) { int min; //printf("sz before decrement:%d\n",p->sz); (p->sz)--; //printf("sz after decrement:%d\n",p->sz); min = p->item[0]; p->item[0] = p->item[p->sz]; p->item[p->sz] = min; //printf("item[0]= %d, Removed = %d\n", p->item[0], min); siftdown(p,0); //printf("sz at end of rmmin_heap:%d\n",p->sz); return(min); }
int get_k_largest_min_heap(int arr[], int size, int k){ if(k<=0 || k>size) return INT_MIN; //min heap with size-k+1 elements int heap[k]; int curr_idx = 0; for(int i=0; i<k; i++){ heap[i] = arr[i]; heap_insert(heap,i); } for(int i=k; i<size; i++){ if(arr[i]<=heap[0]) continue; heap[0] = arr[i]; siftdown(heap,k-1); } return heap[0]; }
status heap_delete(heap * const p_H, size_t const index, generic_ptr * const p_data) { if (index >= p_H -> next_element) return ERROR; *p_data = p_H -> base[index]; p_H -> next_element --; p_H -> base[index] = p_H -> base [p_H -> next_element]; return (siftup(p_H, index) == ERROR || siftdown(p_H, index) == ERROR) ? ERROR : OK; }//heap_delete
static int siftup(PyListObject *heap, Py_ssize_t pos) { Py_ssize_t startpos, endpos, childpos, rightpos, limit; PyObject *tmp1, *tmp2; int cmp; assert(PyList_Check(heap)); endpos = PyList_GET_SIZE(heap); startpos = pos; if (pos >= endpos) { PyErr_SetString(PyExc_IndexError, "index out of range"); return -1; } /* Bubble up the smaller child until hitting a leaf. */ limit = endpos / 2; /* smallest pos that has no child */ while (pos < limit) { /* Set childpos to index of smaller child. */ childpos = 2*pos + 1; /* leftmost child position */ rightpos = childpos + 1; if (rightpos < endpos) { cmp = PyObject_RichCompareBool( PyList_GET_ITEM(heap, childpos), PyList_GET_ITEM(heap, rightpos), Py_LT); if (cmp == -1) return -1; if (cmp == 0) childpos = rightpos; if (endpos != PyList_GET_SIZE(heap)) { PyErr_SetString(PyExc_RuntimeError, "list changed size during iteration"); return -1; } } /* Move the smaller child up. */ tmp1 = PyList_GET_ITEM(heap, childpos); tmp2 = PyList_GET_ITEM(heap, pos); PyList_SET_ITEM(heap, childpos, tmp2); PyList_SET_ITEM(heap, pos, tmp1); pos = childpos; } /* Bubble it up to its final resting place (by sifting its parents down). */ return siftdown(heap, startpos, pos); }
/*======================================================================\ * Author (作者): i.sshe * Date (日期): 2016/03/27 * Others (其他): 删除root节点 * 输出根->把最后一个放到根->堆减1->调整, 一直循环. \*=======================================================================*/ void delete_root_and_sort(int *heap_array, int len) { int temp_len = len; int temp = 0; int i = 0; for (i = 1; i < len + 1; i++) { temp = heap_array[1]; heap_array[1] = heap_array[temp_len]; temp_len--; siftdown(heap_array, 1, temp_len); printf("%d ", temp); } printf("\n"); }
void * heapremove(Heap *h, int k) { void *x; if (k >= h->len) { return 0; } x = h->data[k]; h->len--; set(h, k, h->data[h->len]); siftdown(h, k); siftup(h, k); h->rec(x, -1); return x; }
extern int heapextract( table_t *t, entry_t *item ) { entry_t *p; if (t->size == 0 ) { return 0; } p = &(t->heap[0]); memcpy( item, p, sizeof( entry_t )); memcpy( &(t->heap[0]), &(t->heap[t->size-1]), sizeof(entry_t) ); siftdown(t,t->size, 0); t->size--; return 1; }
static PyObject * heappush(PyObject *self, PyObject *args) { PyObject *heap, *item; if (!PyArg_UnpackTuple(args, "heappush", 2, 2, &heap, &item)) return NULL; if (!PyList_Check(heap)) { PyErr_SetString(PyExc_TypeError, "heap argument must be a list"); return NULL; } if (PyList_Append(heap, item) == -1) return NULL; if (siftdown((PyListObject *)heap, 0, PyList_GET_SIZE(heap)-1) == -1) return NULL; Py_RETURN_NONE; }