大顶堆第二弹----堆排序(递归实现)

package com.datastruct;

import java.util.ArrayList;
import java.util.Arrays;

public class BigHeap {

/*
*交换堆中的两个元素
*/
private void swap(ArrayList<Integer> heapList,int srcIndex,int dstIndex)
{
int tmp = heapList.get(srcIndex);

heapList.set(srcIndex,heapList.get(dstIndex));
heapList.set(dstIndex, tmp);

}

/*
*将指定元素的位置进行上移操作
*/
private void HeapUp(ArrayList<Integer> heapList,int index)
{

if(index > 1)
{
int parent = index / 2;
int parentVal = heapList.get(parent).intValue();
int indexVal =  heapList.get(index).intValue();

if(indexVal > parentVal)
{
swap(heapList,parent,index);
HeapUp(heapList,parent);
}

}
}

/*
*将指定元素的位置进行下移操作
*/
private void HeapDown(ArrayList<Integer> heapList,int index)
{
int heapSize = heapList.size(); //这里进行了重复的计算,可以将作为形参传入，或者将该函数，写成非递归形式

if(index > heapSize - 1)
{//节点不存在
return;
}

int child = index * 2; //左孩子节点

if(child > (heapSize - 2))
{//当前节点为叶子节点，不能进行下移操作，直接返回
//-2是由于最后一个元素已经是要删除的节点，不在计算范围之内
return;
}
else if(child < heapSize - 2)
{//有两个孩子节点
if(heapList.get(child).intValue() < heapList.get(child + 1).intValue())
{
child++; //右孩子结点值大，作为新的父节点
}
}

if(heapList.get(child).intValue() > heapList.get(index).intValue())
{//孩子节点的值大，进行下移
swap(heapList,child, index);
HeapDown(heapList,child);//继续进行下移操作
}

}

/*
*向大顶堆中插入一个元素
*/
public void HeapInsert(ArrayList<Integer> heapList,int value)
{
int heapSize = heapList.size();

if(heapSize == 0)
{//第一个元素不为堆中的元素，跳过
heapList.add(-100);
}

heapList.add(value);
heapSize++; //添加新元素后，改变堆的大小

HeapUp(heapList,heapSize - 1);
}

/*
*从大顶堆中删除一个元素
*/
public void HeapDelete(ArrayList<Integer> heapList,int value)
{
int index = 1,heapSize = heapList.size();
for(; index < heapSize; index++)
{
if(heapList.get(index).intValue() == value)
{
break;
}
}

if (index >= heapSize)
{//元素不存在
return;
}

heapList.set(index, heapList.get(heapSize-1)); //将最后一个叶子节点值赋值到当前节点
HeapDown(heapList,index);

int parent = index / 2;

if(parent > 0 && ( heapList.get(index).intValue() > (Integer)heapList.get(parent).intValue() ))
{//如果下移操作后该元素大于父节点还要进行上移
HeapUp(heapList,index);
}

heapList.remove(heapSize - 1);
}

/*
*调整堆结构
*/
public void heapAdjust(ArrayList<Integer>heapList,int index,int end)
{
int child = -1,heapSize = heapList.size();

end = end > heapSize - 1 ? heapSize - 1 : end; //确保结束正确

while(index <= end / 2)
{//只需调整非叶子节点
child = index * 2; //左孩子节点
if(child + 1 <= end && (heapList.get(child+1).intValue() > heapList.get(child).intValue()) )
{
child += 1; //右孩子节点值大右孩子节点上移
}

if(heapList.get(child).intValue() > heapList.get(index).intValue())
{
swap(heapList, child, index);
index = child;
}
else
{
break;
}
}
}

/*
* 初始化时调整堆结构
* 由于堆是完全二叉树结构，所以只有前一半节点是非叶子节点
*/
public void heapInitAdjust(ArrayList<Integer> heapList)
{
int heapSize = heapList.size();

for(int i = heapSize / 2; i > 0; i--)
{
heapAdjust(heapList, i, heapSize - 1);
}

}

/*
* 堆排序
* 将大顶堆堆顶元素和最后一个元素交换，调整剩下元素的对结构
* 直到调整到最后一个元素就排好序
*/
public void heapSort(ArrayList<Integer>heapList)
{
int heapSize = heapList.size();

for(int i = heapSize - 1; i > 0; i--)
{
swap(heapList, 1, i); //交换堆顶和最后一个元素
heapAdjust(heapList, 1, i - 1);
}
}

/*
*  打印堆元素
*/
public void PrintHeap(ArrayList<Integer> heapList)
{
for(int i = 1; i < heapList.size(); i++)
{
System.out.print(heapList.get(i) + " ");
}

System.out.println();
}

public static void main(String args[])
{
ArrayList<Integer> heapList = new ArrayList<>(Arrays.asList(null,1,3,4,5,8,2,7));

BigHeap bigHeap = new BigHeap();

bigHeap.heapInitAdjust(heapList);
bigHeap.PrintHeap(heapList);

bigHeap.HeapInsert(heapList, 6);
bigHeap.PrintHeap(heapList);

bigHeap.heapSort(heapList);
bigHeap.PrintHeap(heapList);
}
}