组合的生成

点击下载[CSharp源代码之组合.rar]

 

 

  1/**//*
  2=========程序信息========
  3模块简介：组合生成类，从m个数中取出n个数进行组合，其中m > n（非递归生成）
  4版本号:1.0
  5使用语言：c#
  6使用编译器：Visual Studio 2005 .NET
  7每次生成组合所需时间：O(n)
  8作者：贵州大学05级 刘永辉 
  9昵称：SDJL
 10编写时间：2008年8月
 11联系QQ：44561907
 12E-Mail：44561907@qq.com
 13获得更多文章请访问我的博客：www.cnblogs.com/sdjl
 14如果发现BUG或有写得不好的地方请发邮件告诉我:)
 15==========算法介绍=======
 16我们先来看m=5、n=3的组合情况，如下：
 17 1 2 3
 18 1 2 4
 19 1 2 5
 20 1 3 4
 21 1 3 5
 22 1 4 5
 23 2 3 4
 24 2 3 5
 25 2 4 5
 26 3 4 5
 27仔细观察会发现下面的特性(这些特性对于m、n取任何值均成立)：
 28 1、我们可以从前n个数开始进行组合
 29 2、每一次获得下一个组合时只要把最后一个数加1即可
 30 3、如果最后一个数达到了上界，即不能再增加时，则考虑增加前一个数，同样，如果前一个数也达到上界时，那么就增加前前一个数，依此类推
 31 4、不同的位置的数的上界不同，且从右向左依次减小，最后一个是n，第一个是 m-n+1
 32 5、当第i个数增加1且i不等于n时，需要改变第i个数右面的所有数的值，并且是从第i个数开始依次增加1
 33 6、当出现最大的n个数组成的组合后，所有的组合均已生成一遍
 34 */
 35
 36using System;
 37using System.Collections.Generic;
 38using System.Text;
 39
 40namespace SDJL.Combination
 41{
 42    /**//// <summary>
 43    /// 组合类[Write by SDJL]
 44    /// version：1.0
 45    /// </summary>
 46    public class Combination
 47    {
 48        /**//// <summary>
 49        /// m个数的数组
 50        /// </summary>
 51        private object[] m_datas;
 52        /**//// <summary>
 53        /// 用于记录当前状态，
 54        /// </summary>
 55        /// <example>
 56        /// m_state[0]=3 表示生成的组合中第0个元素为所有元素中的第3个
 57        /// </example>
 58        private int[] m_state;
 59        /**//// <summary>
 60        /// 总元素个数
 61        /// </summary>
 62        private int m_m;
 63        /**//// <summary>
 64        /// 取出元素个数
 65        /// </summary>
 66        private int m_n;
 67        /**//// <summary>
 68        /// 是否还有下一个组合
 69        /// </summary>
 70        private bool m_hasNext = true;
 71        
 72        /**//// <summary>
 73        /// 是否还有下一个组合
 74        /// </summary>
 75        public bool HasNext
 76        {
 77            get { return m_hasNext; }
 78        }
 79
 80        /**//// <summary>
 81        /// 用数组构造组合
 82        /// O(m)
 83        /// </summary>
 84        /// <param name="datas">源数组</param>
 85        /// <param name="n">提取的元素个数</param>
 86        public Combination(object[] datas,int n) 
 87        {
 88            m_datas = datas;
 89            m_n = n;
 90            m_m = datas.Length;
 91            m_state = new int[m_n];
 92            for (int i = 0; i < m_n; i++)
 93            {
 94                m_state[i] = i;
 95            }
 96        }
 97
 98        /**//// <summary>
 99        /// 构造基于整数的组合
        /// O(m)
        /// </summary>
        /// <param name="m">总共拥有的整数数</param>
        /// <param name="n">提取元素个数</param>
        public Combination(int m, int n)
        {
            m_n = n;
            m_m = m;

            m_datas = new object[m_m];
            for (int i = 0; i < m_m; i++)
            {
                m_datas[i] = i;
            }
            
            m_state = new int[m_n];
            for (int i = 0; i < m_n; i++)
            {
                m_state[i] = i;
            }
        }

        /**//// <summary>
        /// 获取下一个组合
        /// O(n)
        /// </summary>
        /// <returns>当所有组合均获取完毕后返回null</returns>
        public object[] Next()
        {
            object[] returnArray = null;
            if (m_hasNext)
            {
                returnArray = MakeArray();
                EnterNextState();
            }
            return returnArray;
        }

        /**//// <summary>
        /// 用状态[m_state]生成组合数组
        /// O(n)
        /// </summary>
        /// <returns></returns>        
        private object[] MakeArray()
        {
            object[] returnArray = new object[m_n];
            for (int i = 0; i < m_n; i++)
            {
                returnArray[i] = m_datas[m_state[i]];
            }

            return returnArray;
        }
        
        /**//// <summary>
        /// 进入下一个状态
        /// O(n)
        /// </summary>
        /// <returns>
        /// 当下一个状态存在时返回true,否则返回false
        /// </returns>        
        private bool EnterNextState()
        {
            //k是需要增加1的那个数，起初假设k是最后一个，注意程序中是从0开始编号
            int k = m_n - 1;
            //根据前面的分析，寻找到k的值
            while ((k >= 0) && (m_state[k] + (m_n - k) == m_m))
            {
                k--;
            }
            //如果找到一个需要增加1的数
            if (k>=0)
            {
                //如果这个数在最后的位置上
                if (k==m_n-1)
                {
                    //给这个数增加1
                    m_state[k]++;
                }
                else//否则这个数不在最后的位置上
                {
                    //给这个数增加1
                    m_state[k]++;
                    k++;
                    //改变这个数后面的所有数的值，使得他们的值依次增加1
                    while (k<m_n)
                    {
                        m_state[k] = m_state[k - 1] + 1;
                        k++;
                    }
                }
                m_hasNext = true;
            }
            else//否则找不到需要增加1的数
            {
                //已经不能再次生成组合了
                m_hasNext = false;
            }
            return m_hasNext;
        }
    }
}