比如:从"ABCDEFGHIJKLMNOPQ"中取3个字符所组成的组合的所有可能.

开始的时候用了个递归写，效率也很不错的，这下不用递归，速度又有显著提升,提高了50%.

package CYPL.utils
{

        /**
         * CompositorX
         * 超高效计算组合(个数太长了除外:)
         * @author CYPL
         */
        public class CompositorX
        {
                private var _str : String;
                private var _comList : Array;

                /**
                 * @param str : String  需要进行组合的字串
                 */
                public function CompositorX(str : String) {
                        _str = str;
                        _comList = [];
                }

                /**
                 * @param n :int 取组合长度
                 * @return Array 返回所有的組合
                 */
                public function getComList(n : int) : Array {
                        if(n < 0 || n == 0 || n > _str.length) {
                                throw new Error("参数不符合要求");
                        }
                        if(n == _str.length)return [_str];
                        return fCom(_str.split(""), n);
                }

                private function fCom(items : Array,n : int) : Array {
                        var numList : Array = [];
                        var tempStr : String = "";
                       
                        for(var j : uint = 0;j < n;j++) {
                                numList[j] = j + 1;
                                tempStr += items[j];
                        }
                       
                        var len : int = items.length;
                        var p : int;
                        var k : int = len - n;
                        CYPL:
                        while(true) {
                                //trace(tempStr);
                                _comList.push(tempStr);
                                for(p = n - 1;numList[p] > p + k;) {
                                        p--;
                                        if(p < 0) {
                                                break CYPL;
                                        }
                                }
                                tempStr = tempStr.substr(0, p - n) + items[++numList[p] - 1];
                                while(++p < n) {
                                        tempStr += items[(numList[p] = numList[p - 1] + 1) - 1];
                                }
                        }
                        return _comList;
                }
        }
}

//
import flash.utils.getTimer;
import CYPL.utils.CompositorX;
var timer : int = getTimer();
var com : CompositorX = new CompositorX("ABCDEFGHIJKLMN");
var comList : Array = com.getComList(9);
trace("组合的个数::", comList.length);
trace("耗时::", (getTimer() - timer)+"ms");
//

P D E2180 CPU :
组合的个数:: 2002
耗时:: 3ms

//应该对得起超高效这个名衔~：）