public tuple insertItem(tuple newData) // O(log k) time { int index; tuple pointer; if (heaplimit >= (arraysize - 1)) { grow(); } // if heap is full, grow by factor of 2 index = heaplimit; // A[index].d.m = newData.m; // copy newData onto the bottom of the heap A[index].d.i = newData.i; // A[index].d.j = newData.j; // A[index].d.k = index; A[index].d.enabled = true; pointer = A[index].d; // store pointer to container pointer.enabled = true; heaplimit++; // note the larger heap upsift(index); // upsift new item up to proper spot if (heaplimit > 1) { isempty = false; } return(pointer); }
public tuple popMaximum() // removes and returns heap max, reheapifies { // O(log k) time tuple temp = returnMaximum(); deleteItem(A[1].d); return(temp); }
public void shrink() // decrease size of array A { // O(k) time tuple newtuple; hnode[] B; // scratch space for contraction of A B = new hnode [heaplimit]; // for (int i = 0; i < heaplimit; i++) { B[i].d = A[i].d; } // copy A into B // delete old array of addresses A = new hnode [arraysize / 2]; // shrink A by factor of 2 for (int i = 0; i < heaplimit; i++) { A[i].d = B[i].d; } // copy B into A for (int i = heaplimit; i < (arraysize / 2); i++) // initialize new heap values { newtuple = new tuple(); // A[i].d = newtuple; // A[i].d.m = -4294967296.0; // A[i].d.i = 0; // A[i].d.j = 0; // A[i].d.k = i; // } // delete scratch space B arraysize = arraysize / 2; // update size of array return; }
public void grow() //increase size of array A { tuple newtuple; hnode[] B; // scratch space for expansion of A B = new hnode [arraysize]; // for (int i = 0; i < arraysize; i++) { B[i].d = A[i].d; } // copy A into B // delete old array of addresses A = new hnode [2 * arraysize]; // grow A by factor of 2 for (int i = 0; i < arraysize; i++) { A[i].d = B[i].d; } // copy B into first half of A for (int i = arraysize; i < (2 * arraysize); i++) // initialize new heap values { newtuple = new tuple(); // A[i].d = newtuple; // A[i].d.m = -4294967296.0; // A[i].d.i = 0; // A[i].d.j = 0; // A[i].d.k = i; // } // delete scratch space B arraysize = 2 * arraysize; // update size of array return; }
public void updateItemdub(tuple address, double newStored) // O(log k) time { double oldm = address.m; address.m = newStored; // udpate the dQ stored if (oldm > newStored) { downsift(address.k); } // downsift if old value was larger else { upsift(address.k); } // upsift otherwise return; }
public void updateItem(tuple address, tuple newData) // O(log k) time { double oldm = address.m; address.m = newData.m; // udpate the dQ stored address.j = newData.j; // udpate the community to which to join if (oldm > newData.m) { downsift(address.k); } // downsift if old value was larger else { upsift(address.k); } // upsift otherwise return; }
public modmaxheap(int size) // default constructor { tuple newtuple; heaplimit = 1; // first free location is A[1] arraysize = size + 1; // isempty = true; // heap is initially empty A = new hnode [arraysize]; // allocate array for heap for (int i = 0; i < arraysize; i++) // initialize heap values { newtuple = new tuple(); // A[i].d = newtuple; // A[i].d.m = -4294967296.0; // a very negative value; unlikely to be a valid dQ A[i].d.i = 0; // A[i].d.j = 0; // A[i].d.k = i; // } }
public void deleteItem(tuple address) { tuple swap; int small = heaplimit - 1; int index = address.k; if (heaplimit == 2) // check if deleting last item in heap { A[1].d.m = -4294967296.0; // zero out root data A[1].d.i = 0; // A[1].d.j = 0; // A[1].d.k = 1; // A[1].d.enabled = false; isempty = true; // note the heap's emptiness heaplimit--; // decrement size of heap to empty } else { if (index >= A.Length) { grow(); } A[index].d.m = -4294967296.0; // zero out the deleted item's data A[index].d.i = 0; // A[index].d.j = 0; A[index].d.enabled = false; swap = A[index].d; // swap this element with item at end of heap A[index].d = A[small].d; // A[small].d = swap; // A[index].d.k = index; // note the change in locations A[small].d.k = small; // heaplimit--; // note change in heap size downsift(index); // downsift moved element to new location; O(log k) if ((heaplimit / 2 > heapmin) && (heaplimit == (arraysize / 2))) { shrink(); } // shrink by factor of 2 if necessary } return; }