c++集合类

class intSet

{

public:

     intSet(int capacity = 0);//构造函数，默认初始元素为

     //intSet();

     intSet(const intSet & set);//赋值（拷贝）构造函数

 

     ~intSet(void);//析构函数

    

     void insert(int item);//添加元素

 

     bool isEqual(const intSet & set)const;//判断相等

 

     static intSet union2(intSet set1,intSet set2);//交集

 

     static intSet incorporate2(intSet set1,intSet set2);//并集

 

 

     intSet & operator = (const intSet & set);//重载赋值运算符

 

     void print()const;//打印

 

private:

     void clear();//清空（或使用初始化数组中的所有元素）

     void moveItems(int index);//将index之后的所有元素，向后移动一个位置

     void enlarge();//扩充数组容量

 

     static void copy(const intSet & set1,intSet &set2);//将第一个set中的元素，拷贝到第二个set中

 

private:

     int * m_ptr;//数组头指针

     int m_size;//数组实际数据元素个数

     int m_capacity;//数组当前容量

 

};

 

 

#include <cstddef>

#include <iostream>

#include "intSet.h"

 

intSet::intSet(int capacity)

{

     if(capacity == 0)//当初始容量为时

         m_ptr = NULL;//数组为空

     else

         m_ptr = new int[capacity];//为数组分配新空间

 

     m_size = 0;//起始数组中并没有元素

     m_capacity = capacity;//起始数组的容量

     clear();//为数组赋初值

 

}

 

void intSet::clear()

{

     //数组中所有元素初始化为

     for(int i = 0 ; i < m_capacity ;i++)

         m_ptr[i] = 0;

 

}

 

void intSet::copy(const intSet & set1,intSet &set2)

{

     while(set1.m_size > set2.m_capacity)

     {

         //如果第二个set的空间过小不能容纳set1的所有元素

         set2.enlarge();//扩充set2的空间，知道满足条件为止

     }

 

     //将set1的值赋值给set2

     for(int i = 0 ; i < set1.m_size ; i++)

     {

         set2.m_ptr[i] = set1.m_ptr[i];

     }

     //更改set2元素的个数

     set2.m_size = set1.m_size;

}

 

intSet::intSet(const intSet & set)

{

     m_size = set.m_size;

     m_capacity = set.m_capacity;    

 

     m_ptr = new int[set.m_capacity];

     copy(set,*this);

}

 

void intSet::moveItems(int index)

{

     for(int i = m_size-1 ; i >= index ;--i)

     {

         m_ptr[i+1] = m_ptr[i];     

     }

}

 

void intSet::enlarge()

{

     //将当前数组空间扩充为（原有容量+1）*2

     //+1考虑，如果原来容量为，那么*2无效的情况

     m_capacity = (m_capacity+1) * 2;

    

     //下面复制原来数组的元素，到新分配的数组中

     int * older = m_ptr;

     m_ptr = new int[m_capacity];

 

     for(int i = 0 ; i < m_size ; i++)

         m_ptr[i] = older[i];

 

     //是否原有数组的空间

     if(older != NULL)

         delete [] older;

 

}

 

void intSet::insert(int item)

{

     //如果当前的数组已经填满

     if(m_size >= m_capacity)

     {

         enlarge();//扩充当前数组容量

     }

 

     //将新添加的元素，放入指定的位置

     for(int i = 0 ; i < m_size ; i++)

     {

         if(item <= m_ptr[i])

         {

              if(item == m_ptr[i])

                   return;

              moveItems(i);//将i之后的元素都向后移动一位

              m_ptr[i] = item;

              m_size++;

              return;

         }

     }

     //这个元素应该放到数组的最后

     m_ptr[m_size++] = item;

 

}

 

intSet & intSet::operator = (const intSet & set)

{

     //如果是当前对象本身，直接返回

     if(this == &set)

         return *this;

 

     //如果当前对象已经分配了空间，先释放空间

     if(m_ptr != NULL)

         delete []m_ptr;

 

     //完成一个拷贝复制的过程

     m_size = set.m_size;

     m_capacity = set.m_capacity;

     m_ptr = new int[m_capacity];

     copy(set,*this);

     return *this;

}

 

 

 

bool intSet::isEqual(const intSet & set)const

{

     //当两个set元素个数不同，显然不等

     if(m_size != set.m_size)

         return false;

 

     //逐个元素进行判断

     for(int i = 0 ; i < m_size ; i++)

     {

         if(m_ptr[i] != set.m_ptr[i])

              return false;

     }

     //两个集合相等

     return true;

}

 

intSet intSet::union2(intSet set1,intSet set2)

{

     intSet ret;

     int i,j;

 

     for(i = 0 ,j = 0; i < set1.m_size && j < set2.m_size ;)

         //当两个元素相等

         if(set1.m_ptr[i] == set2.m_ptr[j])

         {

              //将这个元素添加到返回对象

              ret.insert(set1.m_ptr[i]);

              //将两个坐标都移动

              i++;

              j++;

         }

         else if(set1.m_ptr[i] < set2.m_ptr[j])//哪个小，就移动哪个

              i++;

         else

              j++;

     return ret;

}

 

intSet intSet::incorporate2(intSet set1,intSet set2)

{

     //要将ret分配足够的空间

     intSet ret(set1.m_capacity + set2.m_capacity);

     //先将第一个集合拷贝到ret中

     copy(set1,ret);

     //在将第二个集合中的元素一个一个添加到ret集合

     for(int i = 0 ; i < set2.m_size ; i++)

         ret.insert(set2.m_ptr[i]);//注意集合自身会判断是否有重复值

 

     return ret;

}

 

void intSet::print()const

{

     for(int i = 0 ; i < m_size ; i++)

     {

         std::cout<<m_ptr[i]<<"  ";

     }

     std::cout<<std::endl;

}

 

intSet::~intSet(void)

{

     if(m_ptr != NULL)

         delete [] m_ptr;

}

 

 

测试：

#include "intSet.h"

int main()

{

     intSet is(1);

     is.insert(10);

     is.insert(5);

 

     is.insert(7);

     is.insert(2);

     is.insert(3);

     is.insert(5);

     is.insert(1);

     is.insert(6);

 

     intSet is1;

     is1.insert(20);

     is1.insert(10);

     is1.insert(4);

     is1.insert(3);

 

     intSet is3 = intSet::union2(is,is1);

     intSet is4 = intSet::incorporate2(is,is1);

 

     is.print();

     is3.print();

     is4.print();

 

}

 

结果：

1  2  3  5  6  7  10

3  10

1  2  3  4  5  6  7  10  20