排列的字典序生成算法（自然解法）

import java.util.Arrays;
import java.util.Random;


public class permulationGenerator ...{

    public static void main (String[] args) ...{
        while(true)
        ...{
            
            //int n = Math.abs(new Random(10000).nextInt());
            //int[] arr = itoarr(n);
            int[] arr = ...{8,5,4,6,1,7,9,2,3};
            int[] nextArr = gen( arr );
            for (int i=0; i<arr.length; i++)
            ...{
                System.out.print( nextArr[i] );
            }System.out.print(' ');
            System.out.flush();    //force all output
        }
        
        
    }
    /** *//******************* version 1 *****************
    public int gen( int a[], int l )
    {
      int b[l];
      int i=l-1;
      
      int mark1;
      int mark2;
      
      memcpy( a, b, l );
      
      while( b[i-1] > b[i] )
        i--;
      //b[i-1]<b[i]
      mark1=i-1;      ///////////gold times ends
      i=l-1;//reset
      while( b[i] < b[mark1] )
        i--;
      //b[i]>b[mark1]
      mark2=i;
      swap( b[mark1], b[mark2] );
      reverse( b, mark1+1, l-1 );//////////////////////////bottleneck!!!!!!!!!!!
      System.out.println( b );
      return 0;
    }
    ******************* version 2 *****************/
    public static int[] gen ( int[] a )
    ...{
      int[] b = new int[a.length];
      System.arraycopy(a, 0, b, 0, a.length);

      int mark1;
      int mark2;
      int i=b.length-1;    //scan up from right(low weight end)
      while (b[i-1] > b[i] && i>1)//until 0==i-1
        i--;
      //b[i-1]<b[i]>b[i+1]
      mark1=i-1;      ///////////////////////////gold times ends
      
      //review history,jump to [i+1]
      while (i+1<b.length-1 && b[mark1] < b[i])//search maybe null !
      ...{
              i++;
      }
      //b[i-1]>b[mark1]>b[i]
      mark2= (mark1==i-1) ? i : i-1;
      swap (b, mark1, mark2);
      reverse( b, mark1+1, b.length-1 );//////////////////////////bottleneck!!!!!!!!!!!
      return b;
    }
    private static void reverse ( int[] b, int k, int j )
    ...{
        while( k<j )
        ...{
            int t = b[k];
            b[k] = b[j];
            b[j] = t;
            k++;
            j--;
        }
    }
    private static void swap ( int x[], int a, int b ) ...{
        int t = x[a];
        x[a] = x[b];
        x[b] = t;
        }
    private static int[] itoarr ( int i )
    ...{
        int z=1;    //length of decimal,least 1
        int k=i;
        for (; k/10>0; k = k/10)    
            z++;
        int[] a = new int[z];
        k=i;
        for (; z>0; z--, k=k/10)
            a[z-1] = k%10;    //index from 0=1(z)-1
        return a;
    }
}