struct ListNode* mergeKLists(struct ListNode** lists, int listsSize) { struct ListNode* head = (struct ListNode *) malloc(sizeof(struct ListNode)); struct ListNode* travel = head; struct ListNode* temp = NULL; struct ListNode* heap = (struct ListNode *) malloc(sizeof(struct ListNode) * listsSize); int i = 0, p = 0, c = 0, hi = 0; if (listsSize == 0) return NULL; head->next = NULL; for (i = 0; i < listsSize; i ++) { if (*(lists+ i) != 0) *(heap + (hi ++)) = *(*(lists + i)); } //build heap for (i = (listsSize - 1) / 2; i > -1; i --) { //heap down p = i; c = 2 * p + 1; while (c < hi) { if (c + 1 < hi && cmp(heap + c + 1, heap + c) < 0) c ++; if (cmp(heap + p, heap + c) > 0) { swap_heap(heap, p, c); } else break; p = c; c = 2 * p + 1; } } while (heap != NULL) { temp = (struct ListNode *) malloc(sizeof(struct ListNode)); temp->val = heap->val; temp->next = NULL; travel->next = temp; travel = temp; if (heap->next == NULL) { heap[0] = heap[hi - 1]; hi --; if (hi == 0) break; } else { heap->val = heap->next->val; heap->next = heap->next->next; } //*heap = *(heap->next); //heap down p = 0; c = 2 * p + 1; while (c < hi) { if (c + 1 < hi && cmp(heap + c + 1, heap + c) < 0) c ++; if (cmp(heap + p, heap + c) > 0) { swap_heap(heap, p, c); } else break; p = c; c = 2 * p + 1; } } return head->next; }
// Remove a timer from the heap and list of timers. void remove_timer(per_timer_data& timer) { // Remove the timer from the heap. std::size_t index = timer.heap_index_; if (!heap_.empty() && index < heap_.size()) { if (index == heap_.size() - 1) { heap_.pop_back(); } else { swap_heap(index, heap_.size() - 1); heap_.pop_back(); if (index > 0 && Time_Traits::less_than( heap_[index].time_, heap_[(index - 1) / 2].time_)) up_heap(index); else down_heap(index); } } // Remove the timer from the linked list of active timers. if (timers_ == &timer) timers_ = timer.next_; if (timer.prev_) timer.prev_->next_ = timer.next_; if (timer.next_) timer.next_->prev_= timer.prev_; timer.next_ = 0; timer.prev_ = 0; }
void heapify(std::vector< edge3<NUM_T> >& Q, std::vector<NODE_T>& nodes_to_Q, NODE_T i) { do { // TODO: change to loop NODE_T l= LEFT(i); NODE_T r= RIGHT(i); NODE_T smallest; if ( (l<Q.size()) && (Q[l]._dist<Q[i]._dist) ) { smallest= l; } else { smallest= i; } if ( (r<Q.size())&& (Q[r]._dist<Q[smallest]._dist) ) { smallest= r; } if (smallest==i) return; swap_heap(Q, nodes_to_Q, i, smallest); i= smallest; } while (true); } // end heapify
void heap_decrease_key(std::vector< edge3<NUM_T> >& Q, std::vector<NODE_T>& nodes_to_Q, NODE_T v, NUM_T alt) { NODE_T i= nodes_to_Q[v]; Q[i]._dist= alt; while (i>0 && Q[PARENT(i)]._dist>Q[i]._dist) { swap_heap(Q, nodes_to_Q, i, PARENT(i)); i= PARENT(i); } } // heap_decrease_key
// Move the item at the given index up the heap to its correct position. void up_heap(std::size_t index) { while (index > 0) { std::size_t parent = (index - 1) / 2; if (!Time_Traits::less_than(heap_[index].time_, heap_[parent].time_)) break; swap_heap(index, parent); index = parent; } }
// Move the item at the given index up the heap to its correct position. void up_heap(std::size_t index) { std::size_t parent = (index - 1) / 2; while (index > 0 && Time_Traits::less_than(heap_[index].time_, heap_[parent].time_)) { swap_heap(index, parent); index = parent; parent = (index - 1) / 2; } }
// Move the item at the given index down the heap to its correct position. void down_heap(std::size_t index) { std::size_t child = index * 2 + 1; while (child < heap_.size()) { std::size_t min_child = (child + 1 == heap_.size() || Time_Traits::less_than( heap_[child].time_, heap_[child + 1].time_)) ? child : child + 1; if (Time_Traits::less_than(heap_[index].time_, heap_[min_child].time_)) break; swap_heap(index, min_child); index = min_child; child = index * 2 + 1; } }
void heap_remove_first(std::vector< edge3<NUM_T> >& Q, std::vector<NODE_T>& nodes_to_Q) { swap_heap(Q, nodes_to_Q, 0, (NODE_T)Q.size()-1); Q.pop_back(); heapify(Q,nodes_to_Q , 0); } // heap_remove_first