从n个数字中选取m个数字的组合算法（不分序列）

 

#include <vector>

template<class T>
class PermutationCalculate
{
public: 
 PermutationCalculate()
 {
  m_pNumbers = NULL;
  m_nNumbersCount = 0;
 }

 ~PermutationCalculate()
 {
  if (m_pNumbers)
  {
   delete[] m_pNumbers;
  }
  
  purgeCache();  
 }
public:
 void setNumbers(T* nums, unsigned int numsCount)
 {
  if (m_pNumbers)
  {
   delete[] m_pNumbers;
  }

  m_nNumbersCount = numsCount;
  m_pNumbers = new T[numsCount];
  memcpy(m_pNumbers, nums, sizeof(T) * numsCount);
 }

 const std::vector<T*>& caclulate(unsigned int elmCount)
 {
  purgeCache();

  if (m_nNumbersCount == elmCount)
  {
   T* data = new T[elmCount];
   memcpy(data, m_pNumbers, sizeof(T) * elmCount);
   
   m_vecGroupNumbers.push_back(data);

  }
  else if (m_nNumbersCount > elmCount)
  {
   unsigned int k, l; 
   bool findfirst = false, end = false, swap = false;  

   BYTE *flags = new BYTE[m_nNumbersCount];
   memset(flags, 0, m_nNumbersCount);
   for(unsigned int i=0; i < elmCount; i++) 
    flags[i] = 1; 

   
   T* firstData = new T[elmCount];
   memcpy(firstData, m_pNumbers, sizeof(T) * elmCount);
   m_vecGroupNumbers.push_back(firstData);

   while (!end)
   { 
    findfirst=false;  
    swap=false;

    for(unsigned int i = 0; i < m_nNumbersCount; i++)
    { 
     if(!findfirst && flags[i] != 0 )
     { 
      k=i;
      findfirst=true;
     }

     if( (flags[i] != 0) && (flags[i+1] == 0) )
     {
      flags[i]=0; 
      flags[i+1]=1; 
      swap=true;
      for(l=0; l<i-k; l++) 
       flags[l]=flags[k+l]; 
      for(l=i-k; l<i; l++) 
       flags[l]=0;
      if( (k == i) && (i+1 == m_nNumbersCount - elmCount) )
       end=true; 
     } 
     if(swap)
      break; 
    }

    
    T* data = new T[elmCount];
    unsigned int j = 0;
    for(unsigned int i = 0; i < m_nNumbersCount; i++)
     if (flags[i])
      data[j++] = m_pNumbers[i];
    m_vecGroupNumbers.push_back(data);
   }

   delete[] flags;
  }

  return m_vecGroupNumbers;
 }
private:
 void purgeCache()
 {
  std::vector<T*>::iterator it = m_vecGroupNumbers.begin();
  for (; it != m_vecGroupNumbers.end(); it++)
  {
   if (*it)
   {
    delete[] (*it);
   }
  }
  m_vecGroupNumbers.clear();
 }
private:
 T* m_pNumbers;
 unsigned int m_nNumbersCount;
 std::vector<T*> m_vecGroupNumbers;
};