最大堆排序

堆

堆可以用队列来表示。

堆是一种完全二叉树，满足父节点小于左子节点小于右子节点。如果父节点的编号为n

堆排序

// CreateMaxHeap 创建最大堆
// 创建最大堆有两种方法：
// 1. 先创建一个空堆，然后依此给堆添加元素（add)
// 2. 从最后一个非叶子节点开始遍历，对遍历到的节点如果不满足堆的定义（父节点>左子节点>右子节点），交换父子节点的位置，交换后的子节点可能会不满足堆定义，对其进行下沉调整
// 采用第二种方法
func  CreateMaxHeap()[]int{
   h:=[]int{79,66,43,83,30}
   lastNode:=len(h)-1 // 对于go来说，编号是从0开始，而不是从1开始，所以所有的编号都会-1
   lastF:=getParent(lastNode)
   for i:=lastF;i>=0;i--{
      siftDown(h,i)
   }
   return h
}

// getParent 获取子节点的父节点编号
func getParent(node int)int{
   return (node-1)/2 //实际等于 (node+1)/2-1 
}

func siftDown(tree []int,i int){
   left:=i*2+1
   right:=i*2+2
   if left>len(tree)-1{
      return
   }
   var maxNode int 
   // 如果有右子节点，先比较左右子节点的大小，然后再将其与父节点比较
   if right<len(tree) && tree[left]<tree[right]{
      maxNode=right
   }else{
      maxNode=left
   }
   // 交换父子节点并对其子树进行调整
   if tree[maxNode]>tree[i]{
      tree[i],tree[maxNode]=tree[maxNode],tree[i]
      siftDown(tree,maxNode)
   }
}

// deleteMax 删除最大堆的最大值
// 操作方法是删除掉最大堆的0号节点，再将最后一个节点放到0号位置，然后向下调整
func deleteMax(tree []int)[]int{
   tree[0]=tree[len(tree)-1]
   newTree:=tree[:len(tree)-1]
   siftDown(newTree,0)
   return newTree
}

// siftUp 上浮操作跟下沉操作相似,当前堆中父节点要满足大于子节点，并且堆已经是排序好的，如果当前节点不满足堆定义，只需要交换父节点和子节点就可以了。
func siftUp(tree []int ,i int){
   if i==0{
      return
   }
   parent:=getParent(i)
   if tree[i]>tree[parent]{
      tree[i],tree[parent]=tree[parent],tree[i]
      siftUp(tree,parent)
   }else{
      return
   }
}

// add 将新元素添加到队尾，然后进行上浮
func add(tree []int, v int)[]int{
   newTree:= append(tree, v)
   lastNode:=len(newTree)-1
   siftUp(newTree,lastNode)
   return newTree
}

// heapSort 堆排序，删除最大堆的最大值，然后将最后的节点放到0号位置，向下下沉调整，直到整棵树被删完
func heapSort(tree []int)[]int{
   h:=CreateMaxHeap()
   out:=make([]int,0,len(h))
   loop:=len(h)-1
   for i:=loop;i>=0;i--{
      out= append(out, h[0])
      h=deleteMax(h)
   }
   return out
}