17优先队列-二叉堆-堆排序

MaxHeap类
template<class T> class maxHeap : public maxPriorityQueue<T> { public: maxHeap(int initialCapacity = 10); ~maxHeap() {delete [] heap;} bool empty() const {return heapSize == 0;} int size() const{return heapSize;} const T& top(){// return max element if (heapSize == 0) throw std::invalid_argument("empty"); return heap[1]; } void pop(); void push(const T&); void output(std::ostream& out) const; void heapSort(T a[], int n); private: int heapSize; // number of elements in queue int arrayLength; // queue capacity + 1 ？？？ T *heap; // element array void changeLength1D(T * &source, int oldLength, int newLength); void makeHeap(T *, int);//必须与deactivateHeap配对使用 void deactivateHeap(){heap = 0; heapSize=arrayLength=0;}
（13，38，27，50，76，65，49，97）
顺序存储： 在表的右端（后面）入队 O(1)
查找和出队时要在表中找具有最大（小）优先权的元素，O(n)。 链式存储： 在表的左端（前面）入队 O(1)
查找和出队时要在表中找具有最大（小）优先权的元素，O(n)。 如果在存储时，按照递增或递减的次序存放数据元素时，则查找和出队为 O(1)，入队为O(n)。
定义：优先队列：队列中的数据元素都被赋予了一个“优先级”，下一 个得到服务的是队列中优先级最高的数据元素。 常用操作：查找、入队、出队 最小优先队列：查找和出队的元素是具有最小优先级的元素。 最大优先队列：查找和出队的元素是具有最大优先级的元素。
实现方法：线性表
二叉树（二叉堆） 高度优先的左高树
优先队列－线性表
97 76 49 13 50 65 50 76 13 38 97 76 13 65 13 50 27 38
27
49 13
二叉堆－删除过程（大顶堆）
方法： 1.输出堆顶元素之后，以堆中最后一个元素替代之；
2.然后将根结点值与左、右子树的根结点值进行比较，并与 其中大者进行交换；
3.重复上述操作，直至叶子结点，将得到新的堆，称这个从 堆顶至叶子的调整过程为“筛选”
1、将新元素插入到最后，称做当前结点
2、如果当前结点比父结点的优先权小，则结束。否则，进行3。
3、交换当前结点和父结点的位置，重复2.
时间复杂度：O(logn)
课堂练习
插入98
97
76 81
76 49 81 49 81 50 27
65 38
二叉堆－删除过程
（97，76，65，49，50，27，38，13）
优先队列抽象类
template<class T> class maxPriorityQueue { public: virtual ~maxPriorityQueue() {} virtual bool empty() const = 0; // return true iff queue is empty virtual int size() const = 0; // return number of elements in queue virtual const T& top() = 0; // return reference to the max element virtual void pop() = 0; // remove the top element virtual void push(const T& theElement) = 0; // add theElement to the queue };
MaxHeap类－插入函数
template<class T> void maxHeap<T>::push(const T& theElement){ if (heapSize == arrayLength - 1){ changeLength1D(heap, arrayLength, 2 * arrayLength); arrayLength *= 2; } int currentNode = ++heapSize; while (currentNode != 1 && heap[currentNode / 2] < theElement){ heap[currentNode] = heap[currentNode / 2]; currentNode /= 2; } } heap[currentNode] = theElement;
优先队列(priority_Queue)
普通队列：具有FIFO特点的队列，即不能“夹塞”的队列。 优先队列：不具有FIFO特点的队列，即可以“夹塞”的队列。
例如：银行的排队系统
客户被分为：VIP、企业用户、普通用户。 例如：操作系统中进程的调度。
例如：中断系统。
优先队列(priority_Queue)
二叉堆－插入过程
初始 插入81 调整后
（97，76，65，49，50，27，38） （97，76，65，49，50，27，38，81） （97，81，65，76，50，27，38，49）
97
97 76 81 76
65
50 27 38
65
76 49 81 50 27 38 49 81
49
二叉堆－插入过程（大顶堆）
97 76 65 50
}
49 13
27
38
删除97
初始堆的建立
template<class T> void maxHeap<T>::makeHeap(T *theHeap, int theSize){ …… for (int root = heapSize / 2; root >= 1; root—){//向上逐层调整 T rootElement = heap[root]; int child = 2 * root; while (child <= heapSize){ if (child < heapSize && heap[child] < heap[child + 1]) child++; if (rootElement >= heap[child]) break; heap[child / 2] = heap[child]; child *= 2;//向下逐层调整 } heap[child / 2] = rootElement; } } 38
96
27
49 38
83 11
27
9
97
小顶堆
大顶堆
优先队列－二叉堆
树中任一非叶结点的关键字均不大于(或不小于)其左右
孩子(若存在)结点的关键字。 堆是满足下列性质的数列{r1, r2, …，rn}： (小顶堆) 或 (大顶堆)
优先队列－二叉堆
小顶堆： 根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者 的堆称为小顶堆。 大顶堆： 根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者 ，称为大顶堆。 注意： ①堆中任一子树亦是堆。 ②以上讨论的堆实际上是二叉堆(Binary Heap)，类似地可 定义k叉堆。
作业8
template<class E> bool compare(binaryTreeNode<E> *lhd, binaryTreeNode<E> *rhd){ if(!lhd && !rhd) return true; if(!lhd && rhd ) return false; if(lhd && !rhd ) return false; if(lhd->element != rhd->element) return false; if(!compare(lhd->leftChild,rhd->leftChild)) return false; else return compare(lhd->rightChild,rhd->rightChild); } template<class E> bool linkedBinaryTree<E>::compare(linkedBinaryTree<E> &x){ if(this->treeSize != x.treeSize) return false; return ::compare(this->root,x.root); }
97 65 50 27 38
76 81 76 49 81 49 81
98
插入98
MaxHeap类－删除函数
template<class T> void maxHeap<T>::pop(){ if (heapSize == 0) throw std::invalid_argument("heap now is empty"); T lastElement = heap[heapSize--]; int currentNode = 1,child = 2; while (child <= heapSize){ if (child < heapSize && heap[child] < heap[child + 1])child++; if (lastElement >= heap[child]) break; heap[currentNode] = heap[child]; currentNode = child; child *= 2; } heap[currentNode] = lastElement;