自己写算法---java的堆的非递归遍历

import java.io.*;
import java.util.*;
public class Main
{
    public static void main(String args[])
    {
        Scanner cin = new Scanner(System.in);
      //ArrayList<String> list = new ArrayList<String>();
      //Scanner scan = new Scanner(System.in); //获取键盘输入的另一种格式
        int[] list={};  //如果只是在外部申明而没有静态初始化的话，while里面的数组将变为局部变量，从而在循环外部无法获取
        while(cin.hasNextInt())
        {   
            int    s=cin.nextInt();
            list = new int[s];         // 声明数组长度
            for(int i=0;i<list.length;++i){ //给数组赋值
             list[i] = cin.nextInt();
            }
            break;
        }    
        //以下是具体算法，堆排序(非递归)
        //1.初始化堆
          list = confirm(list,list.length);
        //2.开始堆排序

        for(int j=list.length-1;j>=0;--j){
         int tmp=list[j];
         list[j]=list[0];
         list[0]=tmp;
         list = confirm(list,j); //最后一个不需要比较           
        }

     for(int i=0;i<list.length;++i){
                System.out.println(list[i]);
             }
    }

//初始化堆的方法
public static int[] init(int[] list,int cycnum){
           for(int i=cycnum-1;i>=0;--i){
               if(2*i+1>cycnum-1){
                continue;  //到最底层叶子节点时，跳出循环
            }
            int max=0;//记录左右节点较大的一个,值的大小
            int key=0;//记录key的大小
            if(2*i+2>cycnum-1){
                    max=list[2*i+1];
                    key=2*i+1;
            }else{
                    max=list[2*i+1]>list[2*i+2] ? list[2*i+1]:list[2*i+2];
                    key=list[2*i+1]>list[2*i+2] ? 2*i+1 : 2*i+2;
            }
            if(max>list[i]){        
                    list[key]=list[i];
                    list[i]=max;
            }
        }
    return list;
 }

 public static int[] confirm(int[] list,int cycnum){
   for(int j=0;j<=cycnum;++j){  
             list  =   init(list,cycnum); //调用堆的方法,只是调用for循环，没有递归
              if( list  ==   init(list,cycnum)){
                break;
              }
          }
          return list;
 }
}