字符数组全排列组合算法汇总

字符数组全排列

1、递归全排列

public static void Permutation(char[] s, int from, int to) {
        if(to<=1)
            return;

        if(from == to){
            System.out.println(s);
        }else{
            for(int i=from;i<=to;i++){
                swap(s,i,from);
                Permutation(s,from+1,to);
                swap(s,from,i);
            }
        }
}

public static void swap(char[] s, int i, int j) {
        char temp = s[i];
        s[i] = s[j];
        s[j] = temp;
}

2、去重递归全排列

#include<stdio.h>
#include<string>
//交换两个字符
void Swap(char *a ,char *b)
{
    char temp = *a;
    *a = *b;
    *b = temp;
}
//在 str 数组中，[start,end) 中是否有与 str[end] 元素相同的
bool IsSwap(char* str,int start,int end)
{
    for(;start<end;start++)
    {
        if(str[start] == str[end])
            return false;
    }
    return true;
}
//递归去重全排列，start 为全排列开始的下标， length 为str数组的长度
void AllRange2(char* str,int start,int length)
{
    if(start == length-1)
    {
        printf("%s\n",str);
    }
    else
    {
        for(int i=start;i<=length-1;i++)
        {
            if(IsSwap(str,start,i))
            {
                Swap(&str[start],&str[i]); 
                AllRange2(str,start+1,length);
                Swap(&str[start],&str[i]); 
            }
        }
    }
}
void Permutation(char* str)
{
    if(str == NULL)
        return;
    AllRange2(str,0,strlen(str));
}
void main()
{
    char str[] = "abb";
    Permutation(str);
}

3、Permutation 字典序

如何得到346987521的下一个

• 从尾部往前找第一个P(i-1) < P(i)的位置 （找到第一个下降的点）
  3 4 6 <- 9 <- 8 <- 7 <- 5 <- 2 <- 1
  最终找到6是第一个变小的数字，记录下6的位置i-1
• 从i位置往后找到最后一个大于6的数
  3 4 6 -> 9 -> 8 -> 7 5 2 1
  最终找到7的位置，记录位置为m
• 交换位置i-1和m的值
  3 4 7 9 8 6 5 2 1
• 倒序i位置后的所有数据
  3 4 7 1 2 5 6 8 9
  则347125689为346987521的下一个排列
• 代码：

private static void PermutationList()
        {
            int fromIndex, endIndex, changeIndex;
            Sort(0, length - 1);
            do
            {
                // 输出一种全排列
                Output();
                fromIndex = endIndex = length - 1;
                // 向前查找第一个变小的元素
                while (fromIndex > 0 && words[fromIndex] < words[fromIndex - 1])
                    --fromIndex;
                changeIndex = fromIndex;
                if (fromIndex == 0) break;
                // 向后查找最后一个大于words[fromIndex-1]的元素
                while (changeIndex + 1 < length && words[changeIndex + 1] > words[fromIndex - 1])
                    ++changeIndex;
                Swap(fromIndex - 1, changeIndex);   // 交换两个值
                InvertArray(fromIndex, endIndex);   // 对后面的所有值进行反向处理
            } while (true);
        }

字符数组全组合

1、递归

• 字符串的组合：
  给一个字符串，比如ABC， 把所有的组合，即：A, B, C, AB, AC, BC, ABC, 都找出来。
• 解题思路：
  假设我们想在长度为n的字符串中求m个字符的组合。我们先从头扫描字符串的第一个字符。针对第一个字符，我们有两种选择：一是把这个字符放到组合中去，接下来我们需要在剩下的n-1个字符中选取m-1个字符；二是不把这个字符放到组合中去，接下来我们需要在剩下的n-1个字符中选择m个字符。这两种选择都很容易用递归实现。
• 方法1：
  

public static void combiantion(char chs[]){  
    if(chs.length == 0) return ;  

    Stack<Character> stack = new Stack<Character>();  
    for(int i = 1; i <= chs.length; i++){  
        combine(chs, 0, i, stack);  
    }  
}  
//从字符数组中第begin个字符开始挑选number个字符加入list中  
public static void combine(char []chs, int begin, int number, Stack<Character> stack){  
       if(number == 0){  
        System.out.println(stack.toString());  
        return ;  
       }  
       if(begin == chs.length){  
        return;  
       }  
       stack.push(chs[begin]);  
       combine(chs, begin + 1, number - 1, stack);  
       stack.pop();  
       combine(chs, begin + 1, number, stack);  
}  

• 方法2：

public static void combine2(char []chs, int begin, List<String> list){
    if(begin == chs.length){
        return;
    }
    combine2(chs,begin+1,list);
    for(int i = list.size()-1;i>=0;i--){
        list.add(chs[begin]+list.get(i));
    }
    list.add(chs[begin]+"");
}

2、移位

• 输入三个字符 a、b、c，则它们的组合有a b c ab ac bc abc。当然我们还是可以借鉴全排列的思路，利用问题分解的思路，最终用递归解决。不过这里介绍一种比较巧妙的思路 —— 基于位图。
• 假设原有元素n个，最终的组合结果有2^n - 1. 可以使用2^n - 1个位，1表示取该元素，0表示不取。 所以a表示001,取ab是011。
• 001,010,011,100,101,110,111。对应输出组合结果为：a,b,ab,c,ac,bc,abc。
  因此可以循环 1~2^n-1(字符串长度)，然后输出对应代表的组合即可。

    public static void Combination(char [] s){
        if(s.length == 0){
            return;
        }
        int len = s.length;
        int n = 1<<len;//n的二进制为1000
        //从1循环到n-1 即 001 到 111
        for(int i=1;i<n;i++){
            StringBuffer sb = new StringBuffer();
            //每个i的二进制 都是 len 个位
            for(int j=0;j<len;j++){
                if( (i & (1<<j)) != 0) // 判断i的二进制是否包含 (1<<j)
                {
                    sb.append(s[j]);
                }
            }
            System.out.print(sb + " ");
        }   
    }
    for(int j=0;j<len;j++){
        if( (i & (1<<j)) != 0)
     }

参考链接

http://www.cnblogs.com/pmars/p/3458289.html
https://segmentfault.com/a/1190000002710424
http://wuchong.me/blog/2014/07/28/permutation-and-combination-realize/