Exemplo n.º 1
1
void 
heapify (
    struct heap *heap,		/* array of vals/tag to make into heap */
    int index,		/* root of subtree to heapify */
    int nvals,		/* number of values in array */
    int *map			/* maps from tag values to heap indices */
)
{
    double    swap_val;		/* temporary storage for swapping values */
    double    swap_tag;		/* temporary storage for swapping values */
    int       l, r;		/* indices of left & right children */
    int       largest;		/* index of largest value */

    l = left(index);
    r = right(index);

    if (l <= nvals && heap[l].val > heap[index].val)
	largest = l;
    else
	largest = index;

    if (r <= nvals && heap[r].val > heap[largest].val)
	largest = r;

    if (largest != index) {	/* swap index with largest and recurse */
	swap_val = heap[index].val;
	swap_tag = heap[index].tag;

	heap[index].val = heap[largest].val;
	heap[index].tag = heap[largest].tag;

	heap[largest].val = swap_val;
	heap[largest].tag = swap_tag;

	if (map != NULL) {	/* update pointers to heap tags */
	    map[heap[index].tag] = index;
	    map[heap[largest].tag] = largest;
	}

	heapify(heap, largest, nvals, map);
    }
}
Exemplo n.º 2
0
////////////////////////////////////////////////////////////////////
// Performs the heapsort
////////////////////////////////////////////////////////////////////
int* HeapSort::sort() {
	cloneOver(); // reset resArr

	// construct a heap
	heapify();

	// perform the sort
	int i, temp;
	for (i = size - 1; i > 0; i--) {

		// swap node 0 (root) with the node (i)
		swap(&resArr[0], &resArr[i]);
		
		// fix the heap up until immediately before node (i)
		fixHeap(0, i-1);
	}

	return resArr;
}
Exemplo n.º 3
0
/*****************************************************************************
 * heap_extract_max
 *
 * Remove and return the maximum element in the heap.
 *****************************************************************************/
heap_elt_t *heap_extract_max( heap_t *heap )
{
    heap_elt_t	*max;

    if ( heap->size < 1 ) {
	return NULL;
    }

    max = heap->elements[ 0 ];

    heap->elements[ 0 ] = heap->elements[ heap->size - 1 ];
    heap->elements[ 0 ]->index = 0;

    heap->size--;

    heapify( heap, 0 );

    return max;
}
Exemplo n.º 4
0
// Max heap
void heapify(Array array, int idx, int max) {
  int left = 2 * idx + 1;
  int right = 2 * idx + 2;
  int largest;

  if (left < max && cmp(array[left], array[idx]) > 0) {
    largest = left;
  }
  else {
    largest = idx;
  }
  if (right < max && cmp(array[right], array[largest]) > 0) {
    largest = right;
  }
  if (largest != idx) {
    swap(array, idx, largest);
    heapify(array, largest, max);
  }
}
Exemplo n.º 5
0
int mainHeap(){
	int i;
	PQ_ComplHeap * pq = initPQ(10 * sizeof(int));
	LeftHeap * lpq1 = initLeftHeap();
	LeftHeap * lpq2 = initLeftHeap();
	LeftHeap * lpq3 = initLeftHeap();
	heapify(20,pq);
/*
	for(i = pq->size-1 ; i > 0 ; i--)
		delMax(pq);
	printVector(pq->vector);

	printVector(pq->vector);
	printf("\n");
	heapSort(pq);
	printVector(pq->vector);
	printf("\n");
*/    
/*
	insertLeftHeap(17,lpq1);
	insertAsLC(13,lpq1->root);
	insertAsRC(12,lpq1->root);
	insertAsLC(6,lpq1->root->lc);

	insertLeftHeap(15,lpq2);
	insertAsLC(10,lpq2->root);
	insertAsRC(8,lpq2->root);
	travIn_R(lpq1->root);	   
	printf("\n");
	travIn_R(lpq2->root);	 
	lpq3->root = mergeLeftHeap(lpq1->root,lpq2->root);
	printf("\n root : %d \n" , lpq3->root->data);
	travIn_R(lpq3->root);	 
	delMaxLeftHeap(lpq3);
	printf("\n root : %d \n" , lpq3->root->data);
	travIn_R(lpq3->root);	 
*/
	for(i = 1 ; i < 20 ; i++)
		insertLeftHeap(i,lpq1);
	travIn_R(lpq1->root);	 
	return 0;
}
Exemplo n.º 6
0
void heapify(hp_s* hp,int idx)
{
int left = -1;
int right = -1;
int largest_idx = idx;
//printf("Index sent is: %d \n",idx);

//Mark invalid left node data as -1
//Find left node of the idx-left node is at 2i+1
//printf("Array size is %d: \n",hp->hsz);
if((2*idx + 1) < hp->hlen)
	left = hp->arr[2*idx + 1];

//Find right node  of idx-right node is at 2i
if((2*idx + 2) < hp->hlen)
	right = hp->arr[2*idx + 2];


//Find largest node
if(left!= -1 && right != -1)
	largest_idx = left>right?(2*idx + 1):(2*idx + 2);
else if(left != -1)
	largest_idx = (2*idx + 1);
else if (right != -1)
	largest_idx = (2*idx + 2);

largest_idx = hp->arr[idx]>=hp->arr[largest_idx]?idx:largest_idx;

//Organize heap acc to max heap case.
if(largest_idx != idx)
{

	int temp=0;
	temp = hp->arr[largest_idx];
	hp->arr[largest_idx] = hp->arr[idx];
	hp->arr[idx] = temp;

	//printf("Index targeted is: %d\n",largest_idx);
	heapify(hp,largest_idx);
	
}
}
Exemplo n.º 7
0
Arquivo: WDG.c Projeto: mdilshad/DSA
void heapify(struct vertex **Q,int i,int size)
{
	int l,r,small;
	struct vertex *temp;
	l=2*i;
	r=2*i+1;
	if(l<=size && Q[l-1]->d < Q[i-1]->d)
		small=l;
	else
		small=i;
	if(r<=size && Q[r-1]->d < Q[small-1]->d)
		small=r;
	if(i!=small)
	{
		temp=Q[small-1];
		Q[small-1]=Q[i-1];
		Q[i-1]=temp;
		heapify(Q,small,size);
	}		
}
Exemplo n.º 8
0
void heapify(int varArr[],int current,int end)
{
	int l=left_child(current),r=right_child(current);
	int largest;

	if (l<end&&varArr[current]<varArr[l])
		largest=l;
	else
		largest=current;

	if (r<end&&varArr[largest]<varArr[r])
		largest=r;

	if(largest!=current)
	{
		swap(&varArr[current],&varArr[largest]);
		heapify(varArr,largest,end);
	}

}
Exemplo n.º 9
0
        template <typename RandomAccessIterator, typename Predicate = LessPred<RandomAccessIterator> > inline static
        void heapify(RandomAccessIterator first, RandomAccessIterator last, const RandomAccessIterator idx, const Predicate pred)
        {
            auto const left = first + 2 * std::distance(first, idx) + 1;
            auto const right = first + 2 * std::distance(first, idx) + 2;
            auto largest = idx; // largest or smallest

            if (left < last and pred(*idx, *left)) {
                largest = left;
            }

            if (right < last and pred(*largest, *right)) {
                largest = right;
            }

            if (largest != idx) {
                std::iter_swap(idx, largest);
                heapify(first, last, largest, pred);
            }
        }
Exemplo n.º 10
0
/* 
    Build a Min Heap given an array of numbers
    Instead of using insertNode() function n times for total complexity of O(nlogn),
    we can use the buildMinHeap() function to build the heap in O(n) time
*/
void buildMinHeap(minHeap *hp, int *arr, int size) {
    int i ;

    // Insertion into the heap without violating the shape property
    for(i = 0; i < size; i++) {
        if(hp->size) {
            hp->elem = realloc(hp->elem, (hp->size + 1) * sizeof(node)) ;
        } else {
            hp->elem = malloc(sizeof(node)) ;
        }
        node nd ;
        nd.data = arr[i] ;
        hp->elem[(hp->size)++] = nd ;
    }

    // Making sure that heap property is also satisfied
    for(i = (hp->size - 1) / 2; i >= 0; i--) {
        heapify(hp, i) ;
    }
}
Exemplo n.º 11
0
void heapify(collision_heap* heap, short int i){
    short int l = heap_left(i),
              r = heap_right(i),
              largest;
    if(l <= heap->length && heap->heap[l].time < heap->heap[i].time){
        largest = l;
    }else{
        largest = i;
    }
    if(r <= heap->length && heap->heap[r].time < heap->heap[largest].time){
        largest = r;
    }
    if(largest != i){
        collision_data temp;
        temp = heap->heap[i];
        heap->heap[i] = heap->heap[largest];
        heap->heap[largest] = temp;
        heapify(heap, largest);
    }
}
Exemplo n.º 12
0
int pass(struct queue_ptr *q, int n, int time){
    int i;
    if(q->count != 0){
        for(i = 0; i<q->count; i++){
            if(q->heap[i].t1>time+n) continue;
            /* else if(q->heap[i].t1>time){
             q->heap[i].t2 = q->heap[i].t2 = q->heap[i].t2 - (n-(q->heap[i].t1-time));
             if(q->heap[i].t2<0) q->heap[i].t2 = 0;
             }
             */else{
                 q->heap[i].t2 -=n;
                 if(q->heap[i].t2<0) q->heap[i].t2 = 0;
             }
            //else q->heap[i].t2-=n;
        }
    }
    heapify(q, 0, q->count);
    time+=n;
    return time;
}
Exemplo n.º 13
0
void heapify(int k)
{
	int largest = k;

	if (k*2 + 1 < size && heap[largest] < heap[k*2 + 1])
	{
		largest = k*2 + 1;
	}

	if (k*2 + 2 < size && heap[largest] < heap[k*2 + 2])
	{
		largest = k*2 + 2;
	}

	if (k != largest)
	{
		swap(k, largest);
		heapify(largest);
	}
}
Exemplo n.º 14
0
PriorityQueue::PriorityQueue(size_t sourceNodeID)
{
    // Node at first position is reserved for implementation of binary heap
    node[0].nodeID = 0;
    node[0].cost = 0;
    heapSize = NODES;
    // All nodes except sourceNode would have cost of infinity with source node having value of 0
    for(size_t i=1;i<=NODES;i++)
    {
        node[i].nodeID = i;
        indexMap[i-1] = i;
        if(sourceNodeID == i)
            node[i].cost = 0;
        else
            node[i].cost = INF;
    }
    // Heapify all elements
    for(size_t j=heapSize/2;j>=1;j--)
        heapify(j);
}
void heapify(struct Heap* heap, int i)
{
    int largest = i;  
    int left = (i << 1) + 1;
    int right = (i + 1) << 1;
	 
    if (left < heap->size &&
        strcmp(heap->array+left*WSIZE, heap->array+largest*WSIZE)>0)
        largest = left;

    if (right < heap->size &&
		strcmp(heap->array+right*WSIZE, heap->array+largest*WSIZE)>0)
        largest = right;
 
    if (largest != i)
    {
        swap(heap->array+largest*WSIZE, heap->array+i*WSIZE);
        heapify(heap, largest);
    }
}
Exemplo n.º 16
0
int heap_sort(int *a, int len)
{
    int i;
    if(a == NULL)
        return ERROR;

    for(i = 0; i < len; i++)
    {
        //sink(a, i);
        heapify(a, i+1, i, a[i]);
    }

    for(i = len-1; i > 0; i--)
    {
        swap(&a[0], &a[i]);
        sink(a, --len);
    }

    return OK;
}
Exemplo n.º 17
0
void heapSort(int* A, size_t iRoot, size_t iEnd)
{
    // Remove root and place it to the position of last elment
    // Move last elment to root.
    // Actually swap root with last elment till end reaches to start position.
    int rootElement = A[ iRoot ];
    A[iRoot] = A[iEnd];
    A[iEnd] = rootElement;
    
    // Root has been placed into sorted position, decrement last index
    iEnd = iEnd -1 ;
    // Call heapify function and heap short till iEnd reaches to root element
    if( iRoot < iEnd )
    {
        heapify(A, iRoot, iEnd);
        //displayData(A, iRoot, iEnd );
        // Sort Hipified Element
        heapSort(A, iRoot,iEnd);
    }
}
Exemplo n.º 18
0
/*
add packet to the relevent flow
*/
void buffer_write(Packet* p, bool virtual_f)
{
	bool insertP = FALSE;
	Flow* f = getFlow(p, &insertP, virtual_f);
	FHeap* heap = virtual_f ? virtual_flows : flows;
	if (!insertP) //if we didn't insert the packet
	{
		if (flow_isEmpty(f)){ // revived flow
			flow_enqueue(f, p);
			heapify(heap->data, heap->count);
			heap->weight += f->weight;
		}
		else
		{
			flow_enqueue(f, p);
		}

	}

}
Exemplo n.º 19
0
// Initializes the heap using the first length number of items in the array
// values.
struct heapStruct * initHeapfromArray(int* values, int length) {

    int i;
    struct heapStruct* h;

    h = (struct heapStruct*)(malloc(sizeof(struct heapStruct)));
    // We allocate one extra slot, since slot 0 stays unused.
    h->heaparray = (int*)malloc(sizeof(int)*(length+1));

    // Just copy the values into our array.
    for (i=1; i<=length; i++)
        h->heaparray[i] = values[i-1];

    // This is the number of values we copied.
    h->size = length;

    // This takes our random values and rearranges them into a heap.
    heapify(h);
    return h;
}
Exemplo n.º 20
0
void main()
{
	clrscr();
	int n, i, p, k;
	scanf("%d",&n);
	for(i=1;i<=n;H[i]=i,i++)
		scanf("%d",&A[i]);
	hn = n;
	heapify();
	showHeap(n);
	scanf("%d",&p);
	for(i=1;i<=p;i++)
	{
		scanf("%d",&A[++n]);
		insert();
	}
	showHeap(n);
	heapSort();
	showHeap(n);
}
Exemplo n.º 21
0
minmaxheap::minmaxheap(std::string input_file) {
	for (int i = 0; i < 500; i++) {
		heap[i] = -1; // need to have a default value
	}
	std::ifstream infile;
	infile.open ("data.txt");
    std::string line;
    while(std::getline(infile, line)){
        std::stringstream  lineStream(line);
        int value;
        while(lineStream >> value){
        	heap[num_nodes] = value;
        	num_nodes++;
        }
    }
    infile.close();

	for (int i = num_nodes-1; i >= 0; i--) {
		heapify(i);
	}
}
Exemplo n.º 22
0
 /**
  * If item is already in the queue, sets its priority to the sum
  * of the old priority and the new one. If the item is not in the queue,
  * adds it to the queue.
  *
  * returns true if the item was already present
  */
 bool insert_cumulative(T item, Priority priority) {
   // determine if the item is already in the queue
   typename index_map_type::const_iterator iter = index_map.find(item);
   if(iter != index_map.end()) { // already present
     // If it is already present update the priority
     size_t i = iter->second;
     heap[i].second = priority + heap[i].second;
     // If the priority went up move the priority until its greater
     // than its parent
     while ((i > 1) && (priority_at(parent(i)) <= priority)) {
       swap(i, parent(i));
       i = parent(i);
     } 
     // Trickle down if necessary
     heapify(i);  // This should not be necessary
     return false;
   } else { // not already present so simply add
     push(item, priority);
     return true;
   }
 } // end of insert cumulative
Exemplo n.º 23
0
/**
  * Fix heap
  * @param heap Pointer to a heap struct.
  * @param i Current index in heap array.
  */
static void heapify(heap_t * heap, int i)
{
    int l = left(i);
    int r = right(i);

    if (r <= heap->size) {
        int largest;

        if (heap->a[i]->priority > heap->a[r]->priority)
            largest = l;
        else
            largest = r;

        if (heap->a[i]->priority < heap->a[largest]->priority) {
            swap(heap, i, largest);
            heapify(heap, largest);
        }
    } else if ((l == heap->size) && (heap->a[i]->priority < heap->a[l]->priority)) {
        swap(heap, i, l);
    }
}
Exemplo n.º 24
0
void heap::heapify(int x)
{
    int largest = x;
    int l = largest*5+1;
    if(table[l]!=-1)
    {
      for(int j = largest*5 + 1;j<=largest*5 + 5;j++)
      {
        if(table[l]>=table[j] && table[j]!=-1 && table[l]!=-1)
        {
          l = j;
        }
      }
      //std::cout<<"smallest one for index "<<x<<" is "<<table[l]<<std::endl;
      if(table[l]<table[largest])
      {
        swap(l,largest);
        heapify(l);
      }
    }
}
Exemplo n.º 25
0
static inline void astar_replace_route(struct astar_node *node, int x, int y, int cost, int goodness, struct astar_node *next, int location)
{
	/* Replace the old route values with the new ones. */
	node->x = x;
	node->y = y;
	node->cost = cost;
	node->goodness = goodness;
	node->next = next;
	node->order.key.i_key = location;

	/* If the old route was scheduled but not explored yet then fixup the
	 * priority queue to reflect the new goodness of the route. */
	if (node->scheduled) {
		heapify(schedule, 0);
		return;
	}

	/* Otherwise reschedule the route to be explored again. */
	heap_insert(schedule, &node->goodness);
	node->scheduled = 1;
}
//          D        HEAPSORT = ok
void heapify(int i) {
	int L,r,max=0,aux=0;
	L = (2*i)+1;
	r = (2*i)+2;

	if((L<tam_heap) && (vetor[L]>vetor[i])) {
		max = L;
	}
	else
		max = i;

	if((r<tam_heap) && (vetor[r]>vetor[max]))
		max = r;

	if(max != i) {
		aux = vetor[i];
		vetor[i] = vetor[max];
		vetor[max] = aux;
		heapify(max);
	}
}
static void
save_plane(plane_heap_t *heap, lattice_t *lattice, 
		uint32 which_z_block, uint32 which_lattice_xyz)
{
	plane_t *h = heap->entries;

	if (heap->num_entries <= PLANE_HEAP_SIZE - 1) {
		plane_t *s = h + heap->num_entries++;
		s->plane = *lattice;
		s->which_z_block = which_z_block;
		s->which_lattice_xyz = which_lattice_xyz;
		if (heap->num_entries == PLANE_HEAP_SIZE)
			make_heap(h, PLANE_HEAP_SIZE);
	}
	else if (h->plane.score < lattice->score) {
		h->plane = *lattice;
		h->which_z_block = which_z_block;
		h->which_lattice_xyz = which_lattice_xyz;
		heapify(h, 0, PLANE_HEAP_SIZE);
	}
}
Exemplo n.º 28
0
void *bt_heap_cherrypick(struct ptr_heap *heap, void *p)
{
	size_t pos, len = heap->len;

	for (pos = 0; pos < len; pos++)
		if (unlikely(heap->ptrs[pos] == p))
			goto found;
	return NULL;
found:
	if (unlikely(heap->len == 1)) {
		(void) heap_set_len(heap, 0);
		check_heap(heap);
		return heap->ptrs[0];
	}
	/* Replace p with previous last entry and heapify. */
	heap_set_len(heap, heap->len - 1);
	/* len changed. previous last entry is at heap->len */
	heap->ptrs[pos] = heap->ptrs[heap->len];
	heapify(heap, pos);
	return p;
}
Exemplo n.º 29
0
hp_s* build_hp(int *arr,int size)
{

	hp_s* hp = (hp_s*)malloc(sizeof(hp_s));
	hp->hsz = size;
	hp->hlen = 0;
	hp->arr = arr;
	hp->hlen = hp->hsz;

	int i =0;
	i = ((size-2)/2);
	for(i=i;i>=0;i--)
	{
		heapify(hp,i);
		//for(i=0;i<size;i++)
		//	printf("%d ->",arr[i]);
		//printf("\n");

	}
	return hp;
}
Exemplo n.º 30
-1
/*****************************************************************************
 * heap_delete
 *
 * Delete element n from the heap.
 *****************************************************************************/
heap_elt_t *heap_delete( heap_t *heap, GLuint n )
{
    heap_elt_t	*element;

    if ( ( heap->size < 1 ) || ( n >= heap->size ) ) {
	return NULL;
    }

    element = heap->elements[ n ];

    heap->elements[ n ] = heap->elements[ heap->size - 1 ];
    heap->elements[ n ]->index = n;

    heap->size--;

    heapify( heap, n );

    return element;
}