Set Manipulation Class

Advertisemen

Was bored revising Set Theory and I made a class that can perform basic set operations:

#include <iostream>

#include <vector>

#include <algorithm>

#include <cstdarg>

inline std::string boolcast(bool x) { if (!x) return "False"; else return "True"; }

using namespace std;

template <class T>

T LinearSearch(T Value,const vector<T>& List)

{

       for (int i=0;i<List.size();i++)

              if (List[i] == Value)

                     return i;

       return -1;

}

template <class T>

class Set

{

private:

       vector<T> Elements;

public:

       Set() {}

       Set(int argc, ... )

       {

              va_list args;

              va_start(args,argc);

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

                     Elements.push_back(va_arg(args,T));

              va_end(args);

       }

       vector<T> GetElements() const

       {

              return Elements;

       }

       void Sort()

       {

              sort(Elements.begin(), Elements.end());

       }

       void AddElement(T Value)

       {

              Elements.push_back(Value);

       }

       void AddElements(const vector<T>& Values)

       {

              for (int i=0;i<Values.size();i++)

                     Elements.push_back(Values[i]);

       }

       bool IsASubsetOf(const Set& ParamSet)

       {

              for (int i=0; i < this->Elements.size(); i++)

              {

                     if (LinearSearch(this->Elements[i],ParamSet.GetElements()) == -1)

                           return false;

              }

              return true;

       }

       bool IsProperSubsetOf(const Set& ParamSet)

       {

              if (!this->IsEqualTo(ParamSet))

                     if (this->IsASubsetOf(ParamSet))

                           return true;

              return false;

       }

       void Print() const

       {

              cout << "{ ";

              for (int i=0;i<Elements.size()-1;i++)

                     cout << Elements[i] << " , ";

             

              if (Elements.size() > 0)

                     cout << Elements[Elements.size()-1] << " ";

              cout << "}" << endl;

       }

       void RemoveDuplicates() //O(n^2)

       {

              for (int i=0;i<Elements.size();i++)

              {

                     for (int j=i;j<Elements.size();j++)

                     {

                           if (i != j)

                           {

                                  if (Elements[i] == Elements[j])

                                  {

                                         Elements.erase(Elements.begin() + j);

                                         j--;

                                  }

                           }

                     }

              }

       }

       bool IsEqualTo (const Set& ParamSet, bool TakePrecautions=true)

       {

              //remove consts

              Set NewA(*this);

              Set NewB(ParamSet);

              if (TakePrecautions)

              {

                     NewA.RemoveDuplicates();

                     NewB.RemoveDuplicates();

                     NewA.Sort();

                     NewB.Sort();

              }

              if (NewA.Elements.size() != NewB.Elements.size())

                     return false;

              for (int i=0;i<NewA.Elements.size();i++)

                     if (NewA.Elements[i] != NewB.Elements[i])

                           return false;

              return true;

       }

       Set operator| (const Set& ParamSet)

       {

              Set<T> NewSet(*this);

              NewSet.AddElements(ParamSet.Elements);

              NewSet.RemoveDuplicates();

              NewSet.Sort();

              return NewSet;

       }

       Set operator& (const Set& ParamSet)

       {

              Set<T> NewSet;

              //use the smaller set

              if (this->Elements.size() < ParamSet.Elements.size())

              {

                     for (int i=0;i<this->Elements.size();i++)

                           if (LinearSearch(this->Elements[i],ParamSet.Elements) != -1)

                                  NewSet.Elements.push_back(this->Elements[i]);

              }

              else

              {

                     for (int i=0;i<ParamSet.Elements.size();i++)

                           if (LinearSearch(ParamSet.Elements[i],this->Elements) != -1)

                                  NewSet.Elements.push_back(this->Elements[i]);

              }

              return NewSet;

       }

};

int main()

{

       Set<int> A(3,     1,3,4);

       Set<int> B(6,     1,2,3,4,5,6);

       Set<int> C(10,    4,3,1,1,3,1,4,4,4,4,7);

       Set<int> D(5,     0,2,5,6,7);

      

       ((A|B)&(C|D)).Print();

       cout << boolcast(A.IsProperSubsetOf(B)).c_str() << endl;

}

Advertisemen