SwapElements(int index1, int index2) { if (__data.Count < 2) { throw new InvalidOperationException("The heap must contain at least 2 elements."); } if (index1 < 0 || index1 >= __data.Count) { throw new ArgumentOutOfRangeException("index1 must be within the range [0,Count-1]."); } if (index2 < 0 || index2 >= __data.Count) { throw new ArgumentOutOfRangeException("index2 must be within the range [0,Count-1]."); } // Lock the thread -- CRITICAL SECTION BEGIN Monitor.Enter(__data); try { // Do a plain old swap of the elements at index1 and index2 in the heap. PriorityValuePair <T> temp = __data[index1]; __data[index1] = __data[index2]; __data[index2] = temp; } finally { Monitor.Exit(__data); // Unlock the thread -- CRITICAL SECTION END } }
Remove(PriorityValuePair <T> element) { if (IsEmpty) { //throw new InvalidOperationException( "The heap is empty." ); return(false); } // Lock the thread -- CRITICAL SECTION BEGIN Monitor.Enter(__data); bool result = false; try { // Find the element within the heap. int index = __data.IndexOf(element); //Console.WriteLine( "index: " + index + ", count: " + __data.Count ); if (index < 0) { // Return false to indicate that the element was not found in the heap. result = false; } else if (index == __data.Count - 1) { // If we're removing the last element, we can simply remove it. There is no // need to heapify following the removal. __data.RemoveAt(index); result = true; } else { // In most cases, we need to swap the element from the index where it was found // with the last element in the set, then remove the last element (since it is // now the one we aimed to get rid of). Then, once this has been done, we need // to heapify up (and potentially also down) to re-sort the heap. SwapElements(index, __data.Count - 1); __data.RemoveAt(__data.Count - 1); int newIndex = HeapifyBottomUp(index); if (newIndex == index) { HeapifyTopDown(index); } result = true; } } catch (Exception e) { throw e; } finally { Monitor.Exit(__data); // Unlock the thread -- CRITICAL SECTION END } return(result); }
Remove(PriorityValuePair <T> element) { bool result = __heap.Remove(element); if (Count <= 0) { // If the queue is empty now, clear the queue to reset the PriorityAdjustment. Clear(); } return(result); }
Enqueue(PriorityValuePair <T> element) { // Apply the priorty adjustment before adding the new element so it orders correctly. element.Priority -= PriorityAdjustment; // Increment the number of queued items to the priority adjustment updates. NumQueuedItems++; // Add the new element to the queue. __heap.Push(element); }
Dequeue() { PriorityValuePair <T> result = __heap.Pop(); if (Count <= 0) { // If the queue is empty now, clear the queue to reset the PriorityAdjustment. Clear(); } return(result); }
Push(PriorityValuePair <T> element) { // Lock the thread -- CRITICAL SECTION BEGIN Monitor.Enter(__data); try { // Add a new element to the heap at the end of the data list. __data.Add(element); // Heapify bottom up to sort the element into the correct position in the heap. HeapifyBottomUp(__data.Count - 1); } catch (Exception e) { throw e; } finally { Monitor.Exit(__data); // Unlock the thread -- CRITICAL SECTION END } }
Contains(PriorityValuePair <T> element) { // Lock the thread -- CRITICAL SECTION BEGIN Monitor.Enter(__data); bool result = false; try { result = __data.Contains(element); } catch (Exception e) { throw e; } finally { Monitor.Exit(__data); // Unlock the thread -- CRITICAL SECTION END } return(result); }
Contains(PriorityValuePair <T> element) { return(__heap.Contains(element)); }
Add(PriorityValuePair <T> element) { Push(element); }