堆排序（JAVA）

堆排序

1，先让整个数组都变成大根堆结构，建立堆的过程:

1)从上到下的方法，时间复杂度为O(N*logN)

		//一个一个输入，向上调整，O（N*logN）
		for(int i = 0; i< arr.length; i++) {
		heapinsert(arr,i);
		}

2)从下到上的方法，时间复杂度为O(N)

//改良的大根堆建立方法，O（N），具体思路为，直接拿整个数组，
//从最后开始向下调整。
		//由于堆的建立可以建立在前一步的基础上
		//优先级队列==堆 	
		for( int i = arr.length - 1 ; i>=0;i--) {
			heapfy(arr,i,arr.length);
		}
		

2，把堆的最大值和堆末尾的值交换，然后减少堆的大小之后，再去调 整堆，一直周而复始，时间复杂度为O(N*logN)

int heapsize = arr.length;
		swap(arr,0,--heapsize);
		while(heapsize>0) {//堆的大小减小成0之后，排序完成
			heapfy(arr,0,heapsize);
			swap(arr,0,--heapsize);
		}

我的代码：

public class heapsort {
    
	//堆排序，先变成堆:
	//交换最大值，与最后一个值。然后直接减少heapsize，等同于，复位了
	//接着向下调整，找出最大值
    //直到heapsize为零
	
	//可以认为是向上调整
	
	
	
	
	public static void heapSort(int []arr) {
		if(arr == null &&arr.length < 2) {
			return ;
		}
		//一个一个输入，向上调整，O（N*logN）
//		for(int i = 0; i< arr.length; i++) {
//			heapinsert(arr,i);
//		}
		//改良的大根堆建立方法，O（N），具体思路为，直接拿整个数组，从最后开始向下调整。
		//由于堆的建立可以建立在前一步的基础上
		//优先级队列==堆 	
		for( int i = arr.length - 1 ; i>=0;i--) {
			heapfy(arr,i,arr.length);
		}
		
		int heapsize = arr.length;
		swap(arr,0,--heapsize);
		while(heapsize>0) {
			heapfy(arr,0,heapsize);
			swap(arr,0,--heapsize);
		}
	}
	 public static void heapinsert(int [] arr,int index) {
		 while(arr[index]>arr[(index-1)/2]) {//当相等 和为零都会停止。因为不是大于
			 swap(arr,index,(index-1)/2);
			 index=(index-1)/2;
		 }
	 }
	 //实现最大值删去，只需要与最后的值交换，然后数组大小减一，向下调整就行。
	 public static void heapfy(int [] arr,int index,int heapsize) {
		 int left = index*2+1;
		 while(left<heapsize) {
			 int largest = left+1<heapsize && arr[left]<arr[left=1] ? left+1 : left;
			 largest = arr[index]<arr[largest] ? largest:index;
			 if(largest==index) {
				 break;
			 }
			 swap(arr,index,largest);
			 index = largest;
			 left = index * 2 + 1;
		 }