堆排序HeapSort

学习参考：堆排序 Heap Sort、排序六 堆排序

---

 

堆结构：一棵完全二叉树。大根堆：K[ i ] <  K[ 2i ] 、K[ i ] <  K[ 2i+1 ]  。小根堆反之。

本文测试数据：《严奶奶数据结构》P281

由于笔者学业繁忙，没有编写使树形结构可视化的代码。各位读者请心中脑补。

• 堆调整函数：

     protected void HeapAdjust(int [] nums,int a,int b){
         int i;
         for(i=a;a<=b;){
             //左子树=根*2+1，右子树=根*2+2
             int lPos=a*2+1;
             int rPos=(a+1)*2;
             //比较找出左右子树最小的一颗
             int min=nums[a];//根结点
             int nextPos=lPos;//下一个转向的树
             boolean isSwaped=false;
             if(lPos<=b && nums[lPos]<min){
                 nextPos=lPos;
                 min=nums[lPos];
                 isSwaped=true;
             }
             if(rPos<=b && nums[rPos]<min){
                 nextPos=rPos;
                 isSwaped=true;
             }
             if(!isSwaped) break;
             swap(nums,a,nextPos);
             a=nextPos;
         }
     }

函数描述：这个函数用于【建堆】、【筛选】两个操作。在这个函数中，对数组【a，b】中的元素进行处理，其认为除了“a”，在【a+1，b】中的元素都是满足{堆结构}的定义的。

1.求出左右子树的下标

2.进行比较，在左右子树存在的情况下，获得值最小的子树（这个值最小的子树，它的值要比根节点的值小）

3.如果没有这样的子树，跳出循环。

　　有的话，转到子树进行操作，回到 1 进行循环。

• 建堆

        //建堆
        for(i=len/2-1;i>=0;i--){
            HeapAdjust(nums,i,len-1);
        }

认为最下层的子树是规整（满足堆定义）的。通过从下层往上层调整，建立一棵满足堆定义的小根堆。

• 筛选

        //筛选
        int ans[]=new int [len];
        for(i=0;i<len;i++){
            ans[i]=nums[0];
            nums[0]=nums[len-1-i];
            HeapAdjust(nums,0,len-2-i);
        }

1.拿出小根堆的根节点（最小），放入输出数组中

2.把最末尾的节点放入根节点。因为认为现在除了根节点，其他节点都是满足根定义的。所以对根节点使用【堆调整函数】

3.重复 1，直到拿走堆中所有的节点。

---

测试：

输入：49,38,65,97,76,13,27,49

输出：13 27 38 49 49 65 76 97 

 

完整java代码：

public class Main {

    public static void main(String[] args) {
        int []nums={49,38,65,97,76,13,27,49};
        HeapSort sort=new HeapSort(nums);
        System.out.print(sort);
    }

}
    
class HeapSort{
    int [] sortAns;
    HeapSort(){}
    HeapSort(int[] nums){
        int i;
        int len=nums.length;
        //建堆
        for(i=len/2-1;i>=0;i--){
            HeapAdjust(nums,i,len-1);
        }
        //筛选
        int ans[]=new int [len];
        for(i=0;i<len;i++){
            ans[i]=nums[0];
            nums[0]=nums[len-1-i];
            HeapAdjust(nums,0,len-2-i);
        }
        sortAns=ans;
    }
    //对[a,b]的元素进行调整。认为除了a都满足堆的条件
     protected void HeapAdjust(int [] nums,int a,int b){
         int i;
         for(i=a;a<=b;){
             //左子树=根*2+1，右子树=根*2+2
        //     System.out.println("a="+a);
             int lPos=a*2+1;
             int rPos=(a+1)*2;
             //比较找出左右子树最小的一颗
             int min=nums[a];//根结点
             int nextPos=lPos;//下一个转向的树
             boolean isSwaped=false;
             if(lPos<=b && nums[lPos]<min){
                 nextPos=lPos;
                 min=nums[lPos];
                 isSwaped=true;
             }
             if(rPos<=b && nums[rPos]<min){
                 nextPos=rPos;
                 isSwaped=true;
             }
             if(!isSwaped) break;
             swap(nums,a,nextPos);
             a=nextPos;
         }
     }
     void printNums(int[] nums){
         int i;
         for(i=0;i<nums.length;i++) System.out.print(nums[i]+" ");
         System.out.println();
     }
     private void swap(int []arr,int a,int b){
         int tmp=arr[a];
         arr[a]=arr[b];
         arr[b]=tmp;
     }
     public String toString(){
         int i;
         String str=new String("");
         for(i=0;i<sortAns.length;i++) str+=String.valueOf(sortAns[i])+" ";
         str+="\n";
         return str;
     }
}