/*建立最大堆積樹*/
void Build_Max_Heap(int A[],int heap_size)
{
for(int i = (heap_size-2)/2; i >= 0; i--)
{
Max_Heapify(A, i, heap_size);
}
}
void Build_Max_Heap(int A [], int n)
{
for (int i = (n - 1) / 2; i >= 0; --i)
{
Max_Heapify(A, i, n);
}
}
void Build_Tree(int n){
int i;
Build_Max_Heap(n);
for(i=n; i!=0; i--){
Max_Heapify(i, n);
}
}
/*單一子結點最大堆積樹調整*/
void Max_Heapify(int A[], int i, int heap_size)
{
int l = left(i);
int r = right(i);
int largest;
int temp;
if(l < heap_size && A[l] > A[i])
{
largest = l;
}
else
{
largest = i;
}
if(r < heap_size && A[r] > A[largest])
{
largest = r;
}
if(largest != i)
{
temp = A[i];
A[i] = A[largest];
A[largest] = temp;
Max_Heapify(A, largest, heap_size);
}
}
void Build_Max_Heap(int data[]) {
int length = n;
heap_size = n-1;
int i;
for(i=length/2-1; i>=0; i--) { // goes through the remaing nodes of the tree
Max_Heapify(data, i); // runs Max_Heapify for each node
}
}
// 创建一个最大堆
void
Build_Max_Heap() {
heap_size = length;
int i;
for (i = length/2 - 1; i >= 0; --i)
Max_Heapify(i);
}
void BuildMaxHeap(int *a, int n)
{
int i;
for (i=(n-2)/2;i>=0;i--)
{
Max_Heapify(a,i,n-1);
}
}
int Priority_Queue::Heap_Extract_Max()
{
int Max=Max_Heap[0];
Max_Heap[0]=Max_Heap[Number-1];
Max_Heap.pop_back();
Number--;
Max_Heapify(Max_Heap,0);
return Max;
}
void HeapSort(int A [], int n)
{
Build_Max_Heap(A, n);
for (int i = n - 1; i > 0; --i)//从最后一个元素开始，依次与第一个元素交换，然后保持堆的性质，其中i只需要到第二个元素就可以了
{
std::swap(A[0], A[i]);
Max_Heapify(A, 0, i);
}
}
// 返回优先队列的第一个元素，并删去这个元素
int
Heap_Extract_Max() {
if (heap_size < 0)
printf("heap underflow!\n");
int max = A[0];
--heap_size;
Max_Heapify(0);
return max;
}
// 堆排序
void
Heap_Sort() {
Build_Max_Heap();
int i;
for (i = length-1; i > 0; --i) {
A[0]^=A[i]^=A[0]^=A[i];
--heap_size;
Max_Heapify(0);
}
}
//建立初始堆
void Build_Max_Heap(int A[],int heapsize)
{
int i;
//最大的内部节点(有叶子节点的节点)为n/2
//从最大的内部节点到整棵数的根节点建立大顶堆
for(i=heapsize/2;i>=1;i--)
{
Max_Heapify(A,i,heapsize);
}
}
//堆排序算法
void HeapSort(int A[],int len)
{
int i;
Build_Max_Heap(A,len);
//不断的将堆顶元素与数组中索引为len的元素交换
for(i=len;i>=2;i--)
{
swap(&A[1],&A[len]);
len--;
Max_Heapify(A,1,len);
}
}
/*堆積排序程序碼*/
void HeapSort(int A[], int heap_size)
{
Build_Max_Heap(A, heap_size);
int temp;
for(int i = heap_size - 1; i >= 0; i--)
{
temp = A[0];
A[0] = A[i];
A[i] = temp;
Max_Heapify(A, 0, i);
}
}
void HeapSort(int data[]) {
Build_Max_Heap(data); // aftr calling this function all nodes are sorted in each subtree
int i;
int length = n;
for (i =heap_size; i>=1; i--) { // exchange last and first element to be sorted
int temp = data[0];
data[0] = data[i];
data[i] = temp;
heap_size--;
Max_Heapify(data, 0);
}
// after this for loop all subtree will be sorted.
}
void Heap_Sort(int *a, int n)
{
BuildMaxHeap(a,n);
int i;
int temp = a[0];
a[0] = a[n-1];
a[n-1] = temp;
for (i=n-2;i>0;i--)
{
Max_Heapify(a,0,i);
temp = a[0];
a[0] = a[i];
a[i] = temp;
}
}
void Max_Heapify(int A [], int i, int n)
{
int left_child = 2 * i + 1;//分别算出左右子节点
int right_child = 2 * i + 2;
int largest = 0;//保存i节点和子节点中值最大的下标
if (left_child < n && A[left_child] > A[i])//比较i节点和左子节点的大小
largest = left_child;
else
largest = i;
if (right_child < n && A[right_child] > A[largest])//比较largest和右子节点的大小
largest = right_child;
if (largest != i)
{
std::swap(A[i], A[largest]);//交换值，然后继续递归
Max_Heapify(A, largest, n);
}
}
void Max_Heapify(int i, int n){
int l=2*i;
int r=2*i+1;
int largest;
if(l<=n && A[l-1]>A[i-1]){
largest = l;
} else {
largest = i;
}
if(r<=n && A[r-1]>A[largest-1]){
largest =r;
}
if(largest!=i){
int tmp=A[i-1];
A[i-1] = A[largest-1];
A[largest-1] = tmp;
Max_Heapify(largest, n);
}
}
void Max_Heapify(int data[], int i) { // sort sub trees to decide parent by exchanging leaf and root
int l = Left(i);
int r = Right(i);
int largest;
if(l <= heap_size && data[l] > data[i]) {
largest = l;
} else {
largest = i;
}
if(r <= heap_size && data[r] > data[largest]) {
largest = r;
}
if(largest != i) { // decide biggest one and exchange with leaf
int temp = data[i];
data[i] = data[largest];
data[largest] = temp;
Max_Heapify(data, largest);
}
}
void Max_Heapify(int *a, int i, int n)
{
int l = i,temp;
if(2*i+1 <= n && a[2*i+1]>a[l])
{
l = 2*i+1;
}
if(2*i+2 <= n && a[2*i+2]>a[l])
{
l = 2*i+2;
}
if(l!=i)
{
temp = a[i];
a[i] = a[l];
a[l] = temp;
Max_Heapify(a,l,n);
}
}
//建立以i为根节点的大顶堆
void Max_Heapify(int A[], int i,int heapsize)
{
int l=2*i;//取i的左孩子
int r=2*i+1;//取i的右孩子
int largest;//记录根节点、左孩子、有孩子中最大一个的索引
if(l<=heapsize && A[l]>A[i])
largest = l;
else
largest = i;
if(r<=heapsize && A[r]>A[largest])
largest = r;
if(largest!= i)
{
swap(&A[i],&A[largest]);//将最大元素放到根节点上
Max_Heapify(A,largest,heapsize);//处于根为largest的堆有可能被破坏，递归进行调整
}
}
void Priority_Queue::Build_Max_Heap(vector<int> &Heap)
{
for (int j=Number/2;j>=0;j--)
Max_Heapify(Heap,j);
}
void Build_Max_Heap(int n){
int i;
for(i=n/2-1; i!=0; i--){
Max_Heapify(i, n);
}
}
