输出两个数字间全部数字的全排列

package com.wy;

import java.util.Arrays;

/**

 * 获得数据全排列的一个实现算法

 *

 *

 */

public class QuanPaiLie {

      /**

       * 递归输出所有的排列

       * @param array

       * @param begin

       * @param end

       */

      public static void getAllOrder( int[] array, int begin, int end){

             if (begin == end) {

                   check(array);

            } else{

                   for( int i = begin; i <= end; i++){ //数组中的每一个元素挨个当第一个

                         // 交换数据

                         swap(array,begin, i); // 交换首元素和第i个元素

                         getAllOrder(array, begin + 1, end); //递归调用begin + 1, end

                         swap(array,i, begin); // 交换元素i和首元素

                  }

                  

            }

      }

      

      /**

       * 交换数组中的两个元素

       * @param array

       * @param from

       * @param to

       */

      public static void swap(int[] array, int from, int to){

             // 防止无效交换的情况，

             // 比如位置相同，或者两个位置的数据相同

             if(from == to){

                   return;

            }

             int tmp = array[from];

            array[from] = array[to];

            array[to] = tmp;

      }

      

      /**

       * 输出数组中的元素

       * @param array

       */

      public static void check(int[] array){

            System. out.println(Arrays. toString(array));

      }

      

      /**

       * 获得m,n之间所有的数，并以矩阵的形式返回

       * @param m

       * @param n

       * @return

       */

      public static int[] initArray( int m, int n){

             if(n<m){

                  System. out.println( "error input!");

            }

             int[] arr = new int[n-m];

             for( int i = m; i < n; i++){

                  arr[i-m] = i;

                   //System.out.print(i-m+"*"+i+" ");

            }

             //System.out.println();

             return arr;

      }

      public static void main(String[] args){

             int[] array = initArray(31,36);

             getAllOrder(array,0,array.length -1);

      }

}

 

运行结果：

[31, 32, 33, 34]
[31, 32, 34, 33]
[31, 33, 32, 34]
[31, 33, 34, 32]
[31, 34, 33, 32]
[31, 34, 32, 33]
[32, 31, 33, 34]
[32, 31, 34, 33]
[32, 33, 31, 34]
[32, 33, 34, 31]
[32, 34, 33, 31]
[32, 34, 31, 33]
[33, 32, 31, 34]
[33, 32, 34, 31]
[33, 31, 32, 34]
[33, 31, 34, 32]
[33, 34, 31, 32]
[33, 34, 32, 31]
[34, 32, 33, 31]
[34, 32, 31, 33]
[34, 33, 32, 31]
[34, 33, 31, 32]
[34, 31, 33, 32]
[34, 31, 32, 33]