使用败者树对k段归并段进行k-路平衡归并

package dataStructures;

public class KMerge {
	/**
	 * 调整败者树
	 * @param ls
	 * @param b
	 * @param s
	 * @return
	 */
	public static int Adjust(int [] ls,int [] b,int s){
		int n=b.length-1+s;
		for(int i=n/2;i>0;i=i/2){
//			System.out.println("i="+i);
//			System.out.println("||ls["+i+"]="+ls[i]);
			if(b[s]>b[ls[i]]){
				int tmp=s;
				s=ls[i];
				ls[i]=tmp;
			}
		}
		ls[0]=s;
		return s;
	}
	/**
	 * 创建败者树
	 * @param ls
	 * @param b
	 */
	public static void CreateTree(int [] ls,int [] b){
		int k=b.length-1,n=ls.length;
		b[k]=Integer.MIN_VALUE;
		for(int i=0;i<n;i++){
			ls[i]=k;
		}
//		System.out.println("k="+k);
		for(int i=0;i<k;i++){
//			System.out.println("CreateTree i="+i);
			Adjust(ls,b,i);
		}
	}
	/**
	 * 进行K_Merge排序
	 * 对m个初始归并段进行k—路平衡归并，总共有n个元素，需要的时间复杂度为O(log(m)*(n-1))
	 * 他是归并排序的一个变种，所以他是稳定的
	 * @param input
	 * @param k
	 */
	public static void K_Merge(int [] [] input,int k){
		int [] b=new int[k+1];
		int [] count=new int[k];
		for(int i=0;i<k;i++){
			b[i]=input[i][0];
			count[i]=0;
		}
		int [] ls=new int[k];
		CreateTree(ls,b);
		while(b[ls[0]]!=Integer.MAX_VALUE){
			int p=ls[0];
			System.out.print(" "+b[p]);
			count[p]++;
			b[p]=input[p][count[p]];
			Adjust(ls,b,p);
		}
		System.out.println();
	}
	
	public static void main(String [] args){
		int [] ls=new int[5];
		int [] b={10,9,20,15,12,-1};
		KMerge.CreateTree(ls, b);
		System.out.println("++++++++++++++++++测试生成败者树+++++++++++++++");
		for(int i=0;i<5;i++){
			System.out.print(" "+ls[i]);
		}
		System.out.println();
		
		System.out.println("++++++++++++++++++K-merge排序+++++++++++++++");
		int max=Integer.MAX_VALUE;
		int [][] input={{6,15,25,max},
				        {12,37,48,max},
				        {10,15,16,max},
				        {9,18,20,max},
				        {20,22,40,max}};
		KMerge.K_Merge(input, 5);
	}

}