数据结构之堆（java）

   记得以前已经实现过堆结构的一些操作，现在看看总有些不和谐，最近在看了看数据结构，觉得还是写的清晰具体一些，也可以方便以后的复习。下面介绍一下堆存在的一些意义。

   优先级队列可以用于计算机中的任务调度，在计算机中某些程序和活动需要比其他程序和活动先执行，因此需要给他们分配更高的优先级。

   另一个例子是在武器系统中，比如在一个海军巡洋舰系统中。会探测到许多对巡洋舰的威胁，比如来自飞机、导弹、潜水艇的攻击，需要为这些威胁分优先级。例如，离巡洋舰距离近的导弹就比距离远的飞机的优先级更高，这样对应的防范系统（例如地对空导弹）会首先对付它。

   堆是一种树，由它实现的优先级队列的插入和删除的时间复杂度是O（logN).尽管这样删除的时间变慢了一点，但插入的时间快的多了。当速度非常重要，且有很多插入操作时，可以选择对来实现优先级队列。

   堆可分为大根堆和小根堆，详细的概念就不多说了，为了大家可以真正的了解堆的原理，下面给出详细的代码。

/**
 * @author Dylan
 * @date 2015-11-25
 * @see 堆的一个节点
 * */
public class Node {

	private int iData;
	
	public Node(int key){
		this.iData=key;
	}
	
	public int getKey(){
		return iData;
	}
	<pre name="code" class="java">/**
 * @author Dylan
 * @date 2015-11-25
 * @see 堆的相关操作
 * */
public class Heap {

	//该数组用于存储堆的节点
	private Node[] heapArray;
	//数据的存储大小
	private int maxSize;
	//当前数组中存储的节点
	private int currentSize;
	/**
	 * 初始化
	 * */
	public Heap(int size){
		maxSize=size;
		heapArray=new Node[maxSize];
		currentSize=0;
	}
	/**
	 * 判断是否为空
	 * */
	public boolean isEmpty(){
		return (currentSize==0);
	}
	
	/**
	 * 插入节点
	 * */
	public boolean insert(int key){
		if(currentSize==maxSize)      //判断空间是否已满
			return false;
		Node newNode=new Node(key);
		heapArray[currentSize]=newNode; //将新节点插入最后
		trickleUp(currentSize++);		//将节点向上调整
		return true;
	}
	
	/**
	 * 向上筛选
	 * */
	public void trickleUp(int index){
		int parent=(index-1)/2;
		Node bottom=heapArray[index]; //保存当前节点
		while(index>0){
			if(heapArray[parent].getKey()>bottom.getKey())
				break;
			else{
				heapArray[index]=heapArray[parent];
				index=parent;
				parent=(parent-1)/2;
			}
		}
		heapArray[index]=bottom;
	}
	
	/**
	 * 删除节点
	 * */
	public Node remove(){
		if(!isEmpty()){
			Node root=heapArray[0];
			heapArray[0]=heapArray[--currentSize];
			trickleDown(0);
			return root;
		}
		
		return null;
	}
	/**
	 * 向下过滤
	 * */
	public void trickleDown(int index){
		int largeChild,leftChild,rightChild;
		Node top=heapArray[index];
		while(index<currentSize/2){
			leftChild=2*index+1;
			rightChild=leftChild+1;
			if(heapArray[leftChild].getKey()>heapArray[rightChild].getKey())
				largeChild=leftChild;
			else
				largeChild=rightChild;
			if(heapArray[largeChild].getKey()>heapArray[index].getKey())
				heapArray[index]=heapArray[largeChild];
			else
				break;
			index=largeChild;
		}
		heapArray[index]=top;
	}
	
	/**
	 * 用新数据替换旧的节点
	 * */
	public boolean change(int index,int key){
		if(index<0 || index>=currentSize)
			return false;
		int oldKey=heapArray[index].getKey();
		heapArray[index].setKey(key);
		if(oldKey>key)
			trickleDown(index);
		else
			trickleUp(index);
		return true;
	}
	
	/**
	 * 打印堆
	 * */
	public void displayHeap(){
		System.out.print("heapArray:");
		for(int m=0;m<currentSize;m++){
			if(heapArray[m]!=null)
				System.out.print(heapArray[m].getKey()+" ");
		}
		System.out.println();
		
		int column=0; //记录每行节点
		int j=0;	//记录已打印的节点
		int nblank=32; //空格
		int itemsPerRow=1; //每行的节点数
		String dots="----------------------------------";
		System.out.println(dots+dots);
		while(currentSize>0){
			if(column==0)
				for(int k=0;k<nblank;k++){
					System.out.print(" ");
				}
			System.out.print(heapArray[j].getKey());
			//若所有的节点已打印，则跳出
			if(++j==currentSize)
				break;
			if(++column == itemsPerRow){
				System.out.println();
				column=0;
				itemsPerRow *=2;
				nblank /=2;
			}else{
				for(int i=0;i<2*nblank-2;i++)
					System.out.print(" ");
			}
		}
		System.out.println();
		System.out.println(dots+dots);
	}
	
}

public void setKey(int key){this.iData=key;}}

   上面的代码没有堆排序，其实看完上面的代码很容易会想到怎么对一个堆排序，这里就不写出来，留给读者自己完成，以便有一个更清晰的理解。

下面是测试代码：

public class HeapTest {
	/**
	 * 读入字符串
	 * */
	public static String getString(){
		InputStreamReader isr=new InputStreamReader(System.in);
		BufferedReader br=new BufferedReader(isr);
		String str="";
		try {
			str=br.readLine();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return str;
	}
	
	/**
	 * 取字符串的第一个字符
	 * */
	public static char getChar(){
		String s=getString();
		return s.charAt(0);
	}
	
	/**
	 * 输入数字
	 * */
	public static int getInteger(){
		String s=getString();
		return Integer.parseInt(s);
	}

	public static void main(String[] args){
		
		int value,value2;
		
		Heap theHeap=new Heap(31);
		
		boolean success;
		
		theHeap.insert(70);
		theHeap.insert(40);
		theHeap.insert(50);
		theHeap.insert(20);
		theHeap.insert(60);
		theHeap.insert(100);
		theHeap.insert(80);
		theHeap.insert(30);
		theHeap.insert(10);
		theHeap.insert(90);
		
		theHeap.displayHeap();
		
		while(true){
			System.out.print("Enter first letter of : ");
			System.out.println("show, insert, remove,change");
			char choice=getChar();
			switch(choice){
				case 's':
					theHeap.displayHeap();
					break;
				case 'i':
					System.out.print("Enter value to insert:");
					value=getInteger();
					success=theHeap.insert(value);
					if(!success)
						System.out.println("Can't insert !");
					break;
				case 'r':
					if(!theHeap.isEmpty())
						theHeap.remove();
					else
						System.out.println("Can't remove !");
					break;
				case 'c':
					System.out.print("Enter an index:");
					value=getInteger();
					System.out.print("Enter new key:");
					value2=getInteger();
					success=theHeap.change(value, value2);
					if(!success){
						System.out.println("Invalid index");
					}
					break;
				default:break;
			}
		
			theHeap.displayHeap();
		}
		
	}
}

虽然没有写出堆排序的代码，但还是说一下堆排序的效率吧，尽管它比快速排序略慢，但它比快速排序优越的一点是它对初始数据的分布不敏感。在关键字值按某种排列顺序的情况下，快速排序运行的时间复杂度可以降低到O(N*N)级，然而堆排序对任意排列的数据，其排序的时间复杂度都是O(N*logN)