排列组合

    public class XPermutation
    {
        private int _length;
        private int _number;
        private int[] _current;
        private bool _first;

        /// <summary>
        /// 排列组合数据
        /// </summary>
        public int[] Current { get { return _current; } }
        /// <summary>
        /// 数据长度
        /// </summary>
        public int Length { get { return _length; } }
        /// <summary>
        /// 数据个数
        /// </summary>
        public int Number { get { return _number; } }

        /// <summary>
        /// 数据可以重复的排列组合
        /// </summary>
        /// <param name="length">数据长度</param>
        /// <param name="number">数据个数</param>
        public XPermutation(int length,int number)
        {
            _length = length;
            _number = number;
            _current = new int[length];
            Reset();
        }

        public bool Next()
        {
            if (_first)
            {
                _first = false;
                return true;
            }
            for (int i = 0; i < _length; ++i)
            {
                ++_current[i];
                if (_current[i] == _number) _current[i] = 0;
                else break;
            }
            for (int i = 0; i < _length; ++i) if (_current[i] != 0) return true;
            _first = true;
            return false;
        }

        /// <summary>
        /// 重新初始化
        /// </summary>
        public void Reset()
        {
            for (int i = 0; i < _current.Length; ++i) _current[i] = 0;
            _first = true;
        }
    }


    public class Permutation
    {
        private int _length;
        private int[] _current;
        private bool _stop;
        /// <summary>
        /// 排列组合数据
        /// </summary>
        public int[] Current { get { return _current; } }
        /// <summary>
        /// 数据长度
        /// </summary>
        public int Length { get { return _length; } }

        /// <summary>
        /// 排列组合
        /// </summary>
        /// <param name="length">数据长度</param>
        public Permutation(int length)
        {
            _length = length;
            _current = new int[length];
            for (int i = 0; i < _current.Length; ++i) _current[i] = i;
            _stop = true;
        }

        /// <summary>
        /// 重新初始化
        /// </summary>
        public void Reset()
        {
            for (int i = 0; i < _current.Length; ++i) _current[i] = i;
            _stop = true;
        }

        /// <summary>
        /// 获取一个排列组合的数据
        /// </summary>
        /// <returns></returns>
        public bool Next()
        {
            if (_stop)
            {
                _stop = false;
                return true;
            }
            else
            {
                calc(0);
                _stop = false;
                if (_current[0] == _length) return false;
                return true;
            }
        }

        private void calc(int index)
        {
            if (index == _current.Length)
            {
                _stop = true;
                return;
            }
            if ((_current[index]!=-1) && ((index + 1) != _current.Length)) calc(index + 1);
            if (_stop) return;
            for (++_current[index]; _current[index] < _length; ++_current[index])
            {
                int n = 0;
                for (; n < index; ++n) if (_current[n] == _current[index]) break;
                if (n == index) calc(index + 1);
                if (_stop) return;
            }
            if (index != 0) _current[index] = -1;
        }
    }