18 获取给定的序列的所有排列, 组合

前言

本博文部分图片, 思路来自于剑指offer 或者编程珠玑

问题描述

思路

这里有两个问题, 一个是求所有的字符的全排列, 一个是求所有字符的组合

对于问题一, 书上给了一种解法
思路 : 对于一个原始序列, 第一次交换第一个字符 和第一个字符以及后面的字符, 然后递归进入交换第二个字符阶段[同样是交换第二个字符 以及之后的字符], 这样直到交换完所有的字符之后, 打印出序列, 接着返回上一层递归, 交换回刚才的交换的两个字符, 进入下一个交换对象的交换
对于[a, b, c, d], 这样一个序列来说, 第一个字符存在4种交换可能, 第二个字符存在3种, … 最后共有 “4 * 3 * 2 * 1” 种交换序列

接下来一种思路是我实现的比较传统的思路 : 将备选字符放在一个容器, 从中抽取一个数据[不放回], 然后进行递归, 直到抽出的元素个数达到了我们的需求
同样 对于第一次抽取可能存在4种可能, 第二次抽取可能存在3种可能, … 最后共有 “4 * 3 * 2 * 1” 种序列

---

对于问题二

思路 : 我们建立一个抽取规约 : 在抽取了一个元素之后, 我们只能抽取这个元素之后的其他元素[相比于上面传统的思路 选择的余地主要是少了抽取的元素之前的元素]

示范一下 : 比如 “a, b, c”, 假设我们第一次抽取了”b”, 对于问题一的思路, 剩下的备选元素为”a, c”, 然而 对于问题二, 剩下的备选元素为”c”, 因为如果在抽取”b”前面的数据”a”的时候, 可能会造成与第一次抽取”a”的某个组合重叠, so 建立这个规约的目的就是为了防止各个组成元素相同的排列的重复

参考代码

/**
 * file name : Test11CharCompletePermutation.java
 * created at : 9:23:24 AM Jun 8, 2015
 * created by 970655147
 */

package com.hx.test05;

public class Test11CharCompletePermutation {

    // 1. 给定一个char[] 要求打印出全排列
    // 2. 打印出所有的组合
    public static void main(String[] args) {

        char[] chars = new char[] {'a', 'b', 'c', 'd' };
        Deque<Character> deque = new LinkedList<Character>();
        charCompletePermutation(chars, deque, chars.length);
//      charCompletePermutation02(chars, 0);
        Log.horizon();

        deque.clear();
        charCombination(chars, deque);

    }

    // 思路 : 使用一个栈 [或者一个数组 [如果使用数组的话, 直接在下面push的地方改成响应的索引赋值, 然后去掉pop即可] ]来保存排列
        // 每次从chars中拿走一个字符, 然后把剩下的字符传入charCompletePermutation 进行递归
    public static void charCompletePermutation(char[] chars, Deque<Character> deque, int getN) {
        if(chars == null) {
            return ;
        }
        if(getN == 0 ) {
            Log.log(deque);
        }

        for(int i=0; i<chars.length; i++) {
            deque.push(chars[i]);
            charCompletePermutation(copyExcept(chars, i), deque, getN-1);
            deque.pop();
        }

    }
    // 交换start 和start之后的数据
        // 递归交换start+1 和start+1之后的数据
    // 第一位有chars.length中可能, 第二位有chars.length-1种可能, ...
    public static void charCompletePermutation02(char[] chars, int start) {
        if(start == chars.length) {
            Log.log(chars);
            return ;
        }

        for(int i=start; i<chars.length; i++) {
            swap(chars, start, i);
            charCompletePermutation02(chars, start+1);
            swap(chars, i, start);
        }
    }

    // 计算字符序列的全组合
        // 从getN属于[1, chars.length]  获取chars中getN个字符的组合
        // 获取小于(chars.length/2)个数的组合的时候  使用charCombinationForN方法
        // 获取大于(chars.length/2)个数的组合的时候  使用charCombinationForHalfLater方法
    public static void charCombination(char[] chars, Deque<Character> deque) {

        for(int i=1; i<=chars.length/ 2; i++ ) {
            charCombinationForN(chars, deque, i);
        }
        for(int i=chars.length/2+1; i<=chars.length; i++) {
            charCombinationForHalfLater(chars, chars, deque, chars.length-i);
        }

    }

    // 适用于计算sourceChars中的长度小于(sourceChars.length/2)的组合
    // 计算从chars中取出getN个字符的序列
        // 从chars中取出一个字符, 然后递归在其之后的数据中取出getN-1个字符
    private static void charCombinationForN(char[] chars, Deque<Character> deque, int getN) {
        if(getN > chars.length ) {
            return ;
        }
        // 注意 : 这里应该是退出条件之一, 使用完序列之后   应该return
        if(getN == 0) {
            Log.log(deque);
            return ;
        }

        // .. 最多到(chars.length-getN)开始
        int end = chars.length - getN;
        for(int i=0; i<=end; i++) {
            deque.push(chars[i]);
            charCombinationForN(copyAfter(chars, i), deque, getN-1);
            deque.pop();
        }

    }

    // 适用于计算sourceChars中的长度大于(sourceChars.length/2)的组合
    // 计算从chars中取出(chars.length-compeltementyN)个字符的序列
    // 从chars中取出一个字符, 然后递归在其之后的数据中取出(compeltementyN-1)个字符
    private static void charCombinationForHalfLater(char[] sourceChars, char[] chars, Deque<Character> deque, int compeltementyN) {
        if(compeltementyN > chars.length ) {
            return ;
        }
        // 注意 : 这里应该是退出条件之一, 使用完序列之后   应该return
        if(compeltementyN == 0) {
//          Log.log(deque);
            Log.logWithoutLn("[");
            for(char ch : sourceChars) {
                if(! deque.contains(ch)) {
                    Log.logWithoutLn(ch + ", ");
                }
            }
            Log.logWithoutLn("]");
            Log.enter();

            return ;
        }

        // .. 最多到(chars.length-getN)开始
        int end = chars.length - compeltementyN;
        for(int i=0; i<=end; i++) {
            deque.push(chars[i]);
            charCombinationForHalfLater(sourceChars, copyAfter(chars, i), deque, compeltementyN-1);
            deque.pop();
        }

    }

    // 复制除了exceptIdx 之外的其他元素
    private static char[] copyExcept(char[] chars, int excpetIdx) {
        if((excpetIdx < 0) || (excpetIdx >= chars.length) ) {
            return chars;
        }

        char[] newChars = new char[chars.length-1];
        System.arraycopy(chars, 0, newChars, 0, excpetIdx);
        System.arraycopy(chars, excpetIdx+1, newChars, excpetIdx, chars.length-excpetIdx-1);
        return newChars;
    }

    // 注意 : 不包括from
    // 复制chars中from之后的元素
    private static char[] copyAfter(char[] chars, int from) {
        if((from < 0) || (from >= chars.length) ) {
            return chars;
        }

        char[] newChars = new char[chars.length-from-1];
        System.arraycopy(chars, from+1, newChars, 0, newChars.length);
        return newChars;
    }

    // 交换数组中给定的两个索引的数据
    private static void swap(char[] arr, int idx01, int idx02) {
        char tmp = arr[idx01];
        arr[idx01] = arr[idx02];
        arr[idx02] = tmp;
    }


}

效果截图

总结

对于后两者的思路, 更好是使用一个boolean[] 来标记各个索引对应的数据是否可抽取, 但是 这里为了易读, 就这样copyExcept/ copyAfter了

注 : 因为作者的水平有限，必然可能出现一些bug, 所以请大家指出！