排列组合子集合的算法

import  java.util.ArrayList;
import  java.util.Arrays;
import  java.util.LinkedList;
import  java.util.List;
import  java.util.Queue;

/**
 * 
 *  @author  Daniel
 * 排列、组合公共操作应用类
 *
  */
public   class  MyArraysUtil {
     public   static   void  main(String[] args) {
        String array[]  =  { " 0 " , " 1 " , " 2 " , " 3 " , " 4 " , " 5 " , " 6 " , " 7 " , " 8 " , " 9 " };
         // testSubArray();
        testPerm(array, 3 );
         // 递归法测试
        testDaffodil(array, 3 );
    }
    
     /** ************  非递归排列测试  *************** */
     public   static   void  testPerm(Object[] array, int  m){
         long  t1  =  System.currentTimeMillis();
        Object[] arr  =  subArraysByLength(array,m);
        
        List < Object[] >  list  =   new  ArrayList < Object[] > ();
         for  ( int  i  =   0 ; i  <  arr.length; i  ++ ){
            list.add(perm((Object[])arr[i]));
        }
        Object[] _arr  =  (Object[])list.toArray( new  Object[list.size()]);
        System.out.println(Arrays.deepToString(_arr));
         long  t2  =  System.currentTimeMillis();
        System.out.println( " 非递归一共有 "   +  _arr.length  +   " 个全排列集合. " );
        System.out.println( " 非递归一共用时 "   +  (t2 - t1)  +   " 毫秒. " );
    }
    
     /** ************************************************************ */
     /** *******************  排列组合的应用：水仙花数   **************** */  
     /** ************************************************************ */
     public   static   void  testDaffodil(Object[] array, int  m){
         long  t1  =  System.currentTimeMillis();
        Object[] arr  =  subArraysByLength(array,m);
        List < Object[] >  list  =   new  ArrayList < Object[] > ();
         for  ( int  i  =   0 ; i  <  arr.length; i  ++ ){
            List < Object[] >  _list  =   new  ArrayList < Object[] > ();
            Object[] _arr  =  (Object[])arr[i]; // [1,2,3]
            getPerm(_arr,_list);
            list.add((Object[])_list.toArray( new  Object[_list.size()]));
        }
        Object[] rt  =  (Object[])list.toArray( new  Object[list.size()]);
        System.out.println(Arrays.deepToString(rt));
         long  t2  =  System.currentTimeMillis();
        System.out.println( " 递归一共有 "   +  rt.length  +   " 个全排列集合. " );
        System.out.println( " 递归一共用时 "   +  (t2 - t1)  +   " 毫秒. " );
    }
    
     /** ****************** 组合（子集合）测试 ************************ */
     public   static   void  testSubArray(){
        String array[]  =  { " 1 " , " 2 " , " 3 " , " 4 " , " 5 " , " 6 " , " 7 " , " 8 " , " 9 " , " a " , " b " , " c " , " d " , " e " , " f " };
         long  t1  =  System.currentTimeMillis();
        Object[] arr  =  subArraysByLength(array, 8 );
        System.out.println(Arrays.deepToString(arr));
        System.out.println( " 一共有 "   +  arr.length  +   " 个元素. " );
         long  t2  =  System.currentTimeMillis();
        System.out.println( " 一共花费时间 "   +  (t2 - t1)  +   " 毫秒. " );
    }
    
     /** ************************************************************ */
     /** *********        以下是排列操作                    *************** */
     /** *********************************************************** */
    
     /** *************** 第一种方法:递归法 ******************************** */
     /**
     * 对array中的元素全排列，结果以数组的形式保存在list中
     *  @param  array
     *  @param  list
      */
     public   static   void  getPerm(Object[] array,List < Object[] >  list){
        perm(array, 0 ,array.length,list);
    }
     /**
     * 用递归取排列数
     *  @param  array
     *  @param  m
     *  @param  n
     *  @param  list
      */
     private   static   void  perm(Object[] array, int  m,  int  n,List < Object[] >  list){
         if  (array  ==   null ){
            list  =   new  ArrayList < Object[] > ();
             return ;
        }
         // 用array的copy进行排列
        Object[] _array  =  Arrays.copyOf(array, array.length);
         if  (m  <  n - 1 ) {
            perm(_array, m + 1 , n,list);
             for  ( int  i = m + 1 ;i < n;i ++ ) {
                Object t = _array[m];
                _array[m] = _array[i];
                _array[i] = t;
                perm(_array, m + 1 , n,list);

                t = _array[m];
                _array[m] = _array[i];
                _array[i] = t;
            }
        }  else  {
            list.add(_array);
        }
    }
     /** ******************  排列第二种方法：移位法 ********************** */
     /**
     * 不重复元素数组array中的元素全排列
     * 非递归算法
     *  @param  array
     *  @return
      */
     public   static  Object[] perm(Object[] array){
         if  (array  ==   null   ||  array.length  <=   1 ){
             return  array;
        }
        Queue < ArrayWrapper >  queue  =   new  LinkedList < ArrayWrapper > ();
         int  len  =  array.length;
         int  cnt  =   0 ;
        queue.offer( new  ArrayWrapper(array, 0 ));
         while  (cnt  <  len){
            Object[] _array  =  array;
             if  ( ! queue.isEmpty()){
                ArrayWrapper _tmp  =  queue.poll();
                _array  =  _tmp.getArray();
                cnt  =  _tmp.getSign();
            }
             for  ( int  j  =   0 ; j  <  len  -  cnt; j  ++ ){
                ArrayWrapper _aw  =   new  ArrayWrapper(shiftLeft(_array,len  -  cnt,j),cnt + 1 );
                queue.offer(_aw);
            }
            cnt  ++ ;
        }
         int  total  =  queue.size();
        Object[] result  =   new  Object[total];
         for  ( int  i  =   0 ; i  <  total; i  ++ ){
            result[i]  =  queue.poll().getArray();
        }
         return  result;
    }
     /*
     * 有序数组array中的左起m个元素左移n位，最高位回到最低位
      */
     private   static  Object[] shiftLeft(Object[] array, int  m, int  n){
         if  (array  ==   null   ||  array.length  <=   1 ){
             return  array;
        }
         if  (m  <=   1 ){
             return  array;
        }
         int  length  =  array.length;
        Object[] _temp  =   new  Object[length];
         int  _n  =  n  %  m;
        System.arraycopy(array, _n, _temp,  0 , m - _n);
        System.arraycopy(array,  0 , _temp, m - _n, _n);
        System.arraycopy(array, m, _temp, m, length - m);
        
         return  _temp;
    }
    
     /** ************************************************************** */
     /** ************        以下是组合算法及应用 ************* */
     /** ************************************************************** */
    
     /** ******  array中含有eleNum个元素的所有子集****** */        
     /**
     * 取得集合array的所有长度为eleNum的子集合
     * 若eleNum<0则取得所有子集合
     *  @param  array
     *  @param  length
     *  @return
      */
     public   static  Object[] subArraysByLength(Object[] array, int  eleNum){
         if  (array  ==   null ){
             return   null ;
        }
         int  length  =  array.length;
        List < Object[] >  list  =   new  ArrayList < Object[] > ();
         for  ( int  i  =   0 ; i  <  ( 1   <<  length); i  ++ ){
             if  ( ! (eleNum  <   0   ||  get1Cnt(i)  ==  eleNum)){
                 continue ;
            }
            List < Object >  _list  =   new  ArrayList < Object > ();
             for  ( int  j  =   0 ; j  <  length; j  ++ ){
                 if ((i & ( 1 << j))  !=   0 ){
                    _list.add(array[j]);
                }
            }
            list.add(_list.toArray( new  Object[_list.size()]));
        }
        
         return  list.toArray( new  Object[list.size()]);
    }
     /**
     * 取得二进制正整数中"1"的个数
     *  @param  num
     *  @return
      */
     private   static   int  get1Cnt( int  num){
         int  cnt  =   0 ;
         for  (;num  >   0 ;num  >>=   1 ){
            cnt  +=  (num & 1 );
        }
        
         return  cnt;
    }
}

/**
 * array数组封装类，加了个标签sign
 *  @author  Daniel
 *
  */
class  ArrayWrapper{
     private  Object[] array;
     private   int  sign;
    
     public  ArrayWrapper(Object[] array, int  sign){
         this .array  =  array;
         this .sign  =  sign;
    }
     public  Object[] getArray() {
         return  array;
    }
     public   int  getSign() {
         return  sign;
    }
}