排序&&堆排序

package Sort;

import java.util.Arrays;

/**
* 堆排序
*1，堆排序也是选择排序的一种，根据堆的特性，每次把最大或最小值（本次以最大值为例）
*拿出来，按序排列；
2，堆排序是对普通选择排序的一种优化：如果是一个稳定堆，每次在选择最大值时，
只用沿着二叉树其中一个分叉去交换即可，其他分叉符合堆得特性（因是排好的稳定堆），
可以看作是稳定的，不用重排交换，省去了绝大多数的比较交换步骤，数组的数越多，分
支越多，该算法的优势就越明显；

3，第一步，将数组初始化为稳定堆，稳定堆的特性：二叉树之父节点总比其左右孩子节点大！
初始化稳定堆有很多方法，可以从堆顶向堆底方向初始化，也可以从堆底向堆顶方向排列初
始化，也可以通过小三角递归调等完成初始化，本例为理解方便，选用从堆底向堆顶方向初始
化，即，每次从小三角里找到最大值放在父节点，从最后一个小三角向前循环，第一遍，找到
所有数的最大值，第二遍循环找到次最大值放在第二层节点上，依次类推，完成稳定堆得初始化；

4，初始化完稳定堆之后，将选出的最大值与最后一个数字交换放在数组的最后固定下来
（以后循环不再用到此数字），此时除了顶部三角不稳定，下面都是稳定的，根据稳定堆
得特性（父节点总是大于其左右孩子节点），从顶部往底部寻找交换，只沿着变动的那个
分叉交换下去（只用单线一次循环即可），其他分叉不用动，交换完毕后，次最大数又被移到
顶部，此时的堆仍然是一个稳定堆，再将顶部的最大值交换的数组的后面固定下来，重复这个
步骤，依次类推，即可完成；
排序趟数：
1，初始化堆所用趟数：不确定，最大趟数是二叉树的层数，最小一趟

2，初始化堆后所用趟数：length-2次

排序原理：

稳定堆特性，二叉树排序，具体见上述排序思想
* */
public class HeapSort {
static int[] a;
public HeapSort() {
a=new int[] {8,19,2,3,100,99,1000,888,-1,0};
//      a=new int[] {6,5,3,1,8,7,2,4};
}
public HeapSort(int[] a) {
this.a=a;
}
//堆排序
public static void heap_Sort(int[] array) {
int length=array.length;
inteHeap(array, length);//初始化稳定堆
System.out.println("初始化稳定堆"+Arrays.toString(array));
switchData(array, 0, length-1);//交换第一个元素和本轮最后一个元素
//二叉排序
for(int length2=length-1; length2>1; length2--) {//循环length-2次
int index=0;
while(2*index+1<length2) {//只要有左孩子节点就能产生交换，进入循环
if(2*index+2<length2) {//左右孩子都有
int max=index;  //默认是父节点的下标
if(array[max]<array[2*index+1]) {
max=2*index+1;//返回左孩子的下标
}
if(array[max]<array[2*index+2]) {
max=2*index+2;//返回右孩子的下标
}
if(max!=index) {
switchData(array, index, max);
index=max;
}else {
break;//max=index;表示节点最大，下面的堆都是稳定的，不用继续循环
}

}
if(2*index+1<length2 &&2*index+2>=length2)//只有左孩子没有右孩子
if(array[index]<array[2*index+1]) {
switchData(array, index, 2*index+1);

}else {
break;//2*index+1==index表示节点最大，下面的对是最稳定的，不用继续循环
}

}
put();
System.out.println();
switchData(array, 0, length2-1);
put();
System.out.println();
}

}

//初始化堆 所有的根都大于他的孩子
public static  void  inteHeap(int[] array,int length) {
int high=length-1;//最大下标
boolean isChange=false;

//K的初始值就是最大的一个非终端节点
for(int k=(high-1)/2;k>=0;k--) {
//找到最后一个父节点
int left=2*k+1; //左孩子的下标
int right=left+1;//右孩子的下标
//判断是否有节点
if(left<=high) {
int max=left;
if(right<=high) {
if(array[left]<array[right]) {
max=right; //返回左孩子或右孩子中值最大的下标
}
}
//将最大值根父节发交换
if(array[max]>array[k]) {
isChange=true;
switchData(array,max,k);
}
}
}
if(isChange) {//如果一次就能完成稳定堆的初始化，则不需要递归调用，以达到优化算法
inteHeap(array, length);
System.out.println("递归"+Arrays.toString(array));
}
}
//交换数组中俩个数的方法因为要多次用到，所以封装成一个方法
public static void  switchData(int[] array,int index1,int index2) {
array[index1]^=array[index2];
array[index2]^=array[index1];
array[index1]^=array[index2];
}
//遍历
public static void put() {
for (int i : a) {
System.out.print(i+"\t");
}
}
public static void main(String[] args) {
HeapSort hp=new HeapSort();
hp.heap_Sort(a);
hp.put();
}
}