首先为什么要写排列组合？因为排列组合在数学中占有重要的地位，其与概率论也有密切关系；并且排列组合问题在求职的笔试，面试出现的概率特别高，而我在网上又没有搜到比较全面题型的文章；同时，我觉得编写排列组合程序对学习递归也是很有帮助的；当然，最重要的原因是排列组合本身就很有趣！所以就总结下排列组合的各种问法，分两篇写：上篇写排列，下篇写组合。

排列篇

组合篇地址：http://blog.csdn.net/nash_/article/details/8315418

首先从各大IT公司的题中总结出排列组合的对象都是整形数组或字符数组，排列问题可以按输入数据分为两大类：输入数据有重复和无重复，又可以按输出数据分为两大类：输出数据有重复和无重复；而排列问题也偶尔会考非递归。

首先提一下全排列的几种算法：

　　1——字典序法
　　2——递增进位数制法;
　　3——递减进位数制法
　　4——邻位交换法
　　5——n进制数法
　　6——递归生成法
　　7——循环移位法
　　8——回溯法

由本文的目的是总结排列的各种题型，而不是针对某个题型的各种算法，并且由于篇幅有限，感兴趣的朋友可以参考：

http://cache.baidu.com/cm=9f65cb4a8c8507ed4fece763104c8c711923d030678197027fa3c215cc790b1a0161e4bf233f405a8e90613c47f81641e1a43379360622e4cb998e4c8beb932e7f8a2633734ad74705d36ef58d197bd565cd1abfa00e96b0e741e3b9d3a3c82554dd22026df1f39c2c0203cb1fe76541f4d1985f655a07c9e7&p=8b2a9f0e96934eab5bacd3204a4c&user=baidu

由于侧重点在输入数据无重复，所以先看输入数据无重复类型：

其中又可以分为全排列和分组后排列：

首先写基本的全排列：

1.输出数组a的全排列(不可重复取)

如a={1,2,3}。输出123，132，213，231，312，321

这个是最基本，也是最经典的排列

算法思想：可以输出1加上23的全排列，2加13的全排列，3加上12的全排列，运用递归求比如23的全排列..依次递归下去；比如现在要2开头求全排，首先要交换1，2的位置，让a[0]变为2，在用递归求13的所有全排列，前面加个2就是2开头的所有全排列了，最后运用回溯再把1，2调换回来。

代码清单：

public class PaiLie {
    
    public void runPermutation(int[] a){
        getAllPermutation(a, 0);
    }
    /*index用于控制如上述分析中2加上13的所有全列的*/
    public void getAllPermutation(int[] a,int index){

        /*与a的元素个数相同则输出*/
        if(index == a.length-1){
            for(int i = 0; i < a.length; i++){
                System.out.print(a[i] + " ");
            }
            System.out.println();
            return;
        }
        
        for(int i = index; i < a.length; i++){
            
            swap(a ,index, i);
            getAllPermutation(a, index+1);
            swap(a ,index, i);
        }
    }
    public void swap(int[] a, int i, int j) {
    
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void main(String[] args) {
        
        PaiLie robot = new PaiLie();
        int[] a = {1,2,3};
        robot.runPermutation(a);
        
    }
}

2.输出数组a的全排列(可重复取)

如a={1,2}。输出11,12,21,22

如果知道a的length，可以用暴力法求解(n的循环)

如果不知道a的length的情况下：

算法思想：用一个辅助空间b数组存储待输出的排列，用一个参数index记录一个排列的个数

代码清单：

public class PaiLie {
    
    public void runPermutation(int[] a) {
        
        if(null == a || a.length == 0)
            return;
            
        int[] b = new int[a.length];//辅助空间，保存待输出排列数
        getAllPermutation(a, b, 0);
    }

    public void getAllPermutation(int[] a, int[] b, int index) {
        
        if(index == a.length){
            for(int i = 0; i < index; i++){
                System.out.print(b[i] + " ");
            }
            System.out.println();
            return;
        }
            
        for(int i = 0; i < a.length; i++){
            
            b[index] = a[i];
            getAllPermutation(a, b, index+1);
        }
        
    }
    
    public static void main(String[] args){
        
        PaiLie robot = new PaiLie();
        
        int[] a = {1,2,3};
        robot.runPermutation(a);

    }

}

3.输出数组a的全排列(非递归)

如a={1,2,3}。输出123,132,213,231,312,321

全排列的非递归算法也不唯一，我写一个最常用的按字典序非递归算法

所谓字典序就是按照排列数的从大到小或从小到大输出，如123，132，2..，3…

算法思想：如果能按顺序输出序列是这个算法的核心，为了保证按顺序输出先对数组a进行排序。然后从后向前找到第一个顺序对（12是顺序对，21不是）标记为i，然后再从后面向前找到第一个比i大的数，记录为j，随后交换i,j对应的值，再逆序数组a[i+1]到a[length-1]。听到这里大家一定很迷糊，我们来举个例子，比如说2431这个数我们先在i，因为31是逆序，43是逆序，24是顺序，所以i=0；接着我们找j，第一个比2大的数是3，所以j=3，然后交换i，j变成（3，4，2，1）我们看看为什么要交换2,3？因为这个算法的核心思想是按字典序，而2431是以2开头的最大排列，下一个数就得是以3开头了（如果原数是2341按算法就是先要变成2431），接着3421这个数要进行i+1到length-1之间的逆序，变成3124，这个是2431的下一个数。所以可以看出交换后的数从下位开始到最后一定是一个逆序排列，所以逆序后才变成了相对的“最小值”。

–代码清单：

import java.util.Arrays;


public class PaiLie {
    
        public void runNoRecursionOfPermutation(int[] a){
        
        Arrays.sort(a);//对数组排序
        while(true){
            
            printArray(a);//输出一个排列
            
            int i;//从后向前，记录一对顺序值中的小值下标
            int j;//从后向前，记录比i大的第一个数
            
            for(i = a.length-2; i >= 0; i--){
                
                if(a[i] < a[i+1])//如果找到i跳出
                    break;
                else if(i == 0)//说明是最大逆序数退出函数
                    return;
            }
            for(j = a.length-1; j > i; j--){
                if(a[j] > a[i])//找到j跳出
                    break;
            }
            swap(a, i, j);//交换i，j
            reverse(a, i+1, a.length-1);//翻转
        }
    }
    public void swap(int[] a, int i, int j) {
    
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    public void reverse(int[] a, int i, int j){
        while(i < j)
            swap(a, i++, j--);
    }
    
        public void printArray(int[] a) {
        
        for(int i = 0; i < a.length; i++){
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        
        PaiLie robot = new PaiLie();
        int[] a = {1,2,3};
        robot.runNoRecursionOfPermutation(a);
        
    }
}

4.输出从数组a中取n个数的所有排列

如a={1,2,3} n=2输出12，21，13，31，23，32

这道题可以看作是排列组合的综合题，有关组合问题也可以参考我写的组合篇

http://blog.csdn.net/nash_/article/details/8315418

算法思想：求出a中选取n个数的所有组合，分别对其进行全排列。

代码清单：

public class PaiLie {
    
    public void runPermutation(int[] a, int n) {
        
        if(null == a || a.length == 0 || n <= 0 || n > a.length)
            return;
            
        int[] b = new int[n];//辅助空间，保存待输出组合数
        getCombination(a, n , 0, b, 0);
    }

    public void getCombination(int[] a, int n, int begin, int[] b, int index) {
        
        if(n == 0){//如果够n个数了，输出b数组
            
            getAllPermutation(b,0);//得到b的全排列
            return;
        }
            
        for(int i = begin; i < a.length; i++){
            
            b[index] = a[i];
            getCombination(a, n-1, i+1, b, index+1);
        }
        
    }
    public void getAllPermutation(int[] a,int index){

        /*与a的元素个数相同则输出*/
        if(index == a.length-1){
            for(int i = 0; i < a.length; i++){
                System.out.print(a[i] + " ");
            }
            System.out.println();
            return;
        }
        
        for(int i = index; i < a.length; i++){
            
            swap(a ,index, i);
            getAllPermutation(a, index+1);
            swap(a ,index, i);
        }
    }
    public void swap(int[] a, int i, int j) {
    
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    public static void main(String[] args){
        
        PaiLie robot = new PaiLie();
        
        int[] a = {1,2,3};
        int n = 2;
        robot.runPermutation(a,n);

    }

}

输入数据有重复类型：

这类如a={1,3,2,3} 3出现了两次，用以上排列会造成输出重复。

5.输出数组a的全排列(递归)

如a={1,1,2}输出112,121,211

算法思想：我们改进一下1的算法，在for中判断是否有包含重复元素，也就是index和i之间是否有和a[i]相等的值，比如对于2313这个数列，当index=0(a[index] = 2),i=3(a[i] = 3)的时候,如果要交换这两个数变成3312的话就是计算重复了，因为它们之间有1个3，当i=1的时候，它已经转换过3312了。所以加一个函数判断中间有没有包含重复元素，如有没有重复元素，再做交换。

代码清单：

public class PaiLie {
    
    public void runPermutation(int[] a){
        getAllPermutation(a, 0);
    }
    /*index用于控制如上述分析中2加上13的所有全列的*/
    public void getAllPermutation(int[] a,int index){

        /*与a的元素个数相同则输出*/
        if(index == a.length-1){
            for(int i = 0; i < a.length; i++){
                System.out.print(a[i] + " ");
            }
            System.out.println();
            return;
        }
        
        for(int i = index; i < a.length; i++){
            
            if(contains(a, index ,i))
                continue;
            swap(a ,index, i);
            getAllPermutation(a, index+1);
            swap(a ,index, i);
        }
    }
    
    public boolean contains(int[] a, int m, int n) {
        
         for (int i = m; i < n; i++) {

               if (a[i] == a[n])
                return true;
              }
        return false;
    }
    public void swap(int[] a, int i, int j) {
    
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void main(String[] args) {
        
        PaiLie robot = new PaiLie();
        int[] a = {1,1,2};
        robot.runPermutation(a);
        
    }
}

6.输出数组a的全排列(非递归)

如a={1,1,2}输出112,121,211

算法思想：对于重复输入数据的非递归，我们仍然可以用算法3，因为排序后，相等的数都挨着，而我们认为相等的两个数不构成“有序”，所以就不会造成重复，并且按字典序输出所有排列。

代码清单：

import java.util.Arrays;


public class PaiLie {
    
       public void runNoRecursionOfPermutation(int[] a){
        
        Arrays.sort(a);//对数组排序
        while(true){
            
            printArray(a);//输出一个排列
            
            int i;//从后向前，记录一对顺序值中的小值下标
            int j;//从后向前，记录比i大的第一个数
            
            for(i = a.length-2; i >= 0; i--){
                
                if(a[i] < a[i+1])//如果找到i跳出
                    break;
                else if(i == 0)//说明是最大逆序数退出函数
                    return;
            }
            for(j = a.length-1; j > i; j--){
                if(a[j] > a[i])//找到j跳出
                    break;
            }
            swap(a, i, j);//交换i，j
            reverse(a, i+1, a.length-1);//翻转
        }
    }
    public void swap(int[] a, int i, int j) {
    
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    public void reverse(int[] a, int i, int j){
        while(i < j)
            swap(a, i++, j--);
    }
    public void printArray(int[] a) {
        
        for(int i = 0; i < a.length; i++){
            System.out.print(a[i] + " ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        
        PaiLie robot = new PaiLie();
        int[] a = {1,2,3};
        robot.runNoRecursionOfPermutation(a);
        
    }
}

如果您有其他的排列问题请告诉博主，谢谢！

==================================================================================================

  作者：nash_  欢迎转载，与人分享是进步的源泉！

  转载请保留原文地址：http://blog.csdn.net/nash_/article/details/8351611

===================================================================================================