Node.h

#ifndef NODE_H
#define NODE_H


// Helper class used at the Centers rearrangement phase
template <class T1, class T2, int key>
class Node2 {

  friend bool operator<(const Node2<T1,T2,key>& left, const Node2<T1,T2,key>& right)
  {
   return (key == 0) ? (left.a < right.a) : (left.b < right.b);
  };


  friend bool operator>(const Node2<T1,T2,key>& left, const Node2<T1,T2,key>& right)
  {
   return (key == 0) ? (left.a > right.a) : (left.b > right.b);
  };    
  
  friend bool operator==(const Node2<T1,T2,key>& left, const Node2<T1,T2,key>& right)
  {
   return (key == 0) ? (left.a == right.a) : (left.b == right.b);
  };
  
  public:
    
    T1 a;    
    T2 b;    
    
    Node2(T1 x, T2 dist) {
      this->a = a;
      this->b = b;
    };    
};
    
/*template <class T1, class T2, int key>
bool operator<(const Node2<T1,T2,key>& left, const Node2<T1,T2,key>& right) {
  return (key == 0) ? (left.a < right.a) : (left.b < right.b);
};



template <class T1, class T2, int key>
bool operator>(const Node2<T1,T2,key>& left, const Node2<T1,T2,key>& right) {
  return (key == 0) ? (left.a > right.a) : (left.b > right.b);
};



template <class T1, class T2, int key>
bool operator==(const Node2<T1,T2,key>& left, const Node2<T1,T2,key>& right) {
  return (key == 0) ? (left.a == right.a) : (left.b == right.b);
};*/


// Helper class used at the Centers rearrangement phase
template <class T1, class T2, class T3, int key>
class Node3 {

  friend bool operator<(const Node3<T1,T2,T3,key>& left, const Node3<T1,T2,T3,key>& right)
  {    
      if (key == 0)
        return left.a < right.a;
    
      else if (key == 1)
        return left.b < right.b;
    
      else if (key == 2)
        return left.c < right.c;
    
      else
        return false;
  };

  friend bool operator>(const Node3<T1,T2,T3,key>& left, const Node3<T1,T2,T3,key>& right)
  {
      if (key == 0)
        return left.a > right.a;
    
      else if (key == 1)
        return left.b > right.b;
    
      else if (key == 2)
        return left.c > right.c;
    
      else
        return false;
   };
    
  friend bool operator==(const Node3<T1,T2,T3,key>& left, const Node3<T1,T2,T3,key>& right)
  {    
      if (key == 0)
        return ( (left.b == right.b && left.c == right.c) || (left.c == right.b && left.b == right.c) );
    
      else if (key == 1)
        return ( (left.a == right.a && left.c == right.c) || (left.c == right.a && left.a == right.c) );
        
      else if (key == 2)
        return ( (left.b == right.b && left.a == right.a) || (left.a == right.b && left.b == right.a) );
        
      else
        return false;  
  };
  
  public:
    
    T1 a;    
    T2 b;    
    T3 c;    

    Node3(T1 a, T2 b, T3 c) {
      this->a = a;
      this->b = b;
      this->c = c;
    };    
};
    
  

/*template <class T1, class T2, class T3, int key>
bool operator<(const Node3<T1,T2,T3,key>& left, const Node3<T1,T2,T3,key>& right) {

  if (key == 0)
    return left.a < right.a;

  else if (key == 1)
    return left.b < right.b;

  else if (key == 2)
    return left.c < right.c;

  else
    return false;

};



template <class T1, class T2, class T3, int key>
bool operator>(const Node3<T1,T2,T3,key>& left, const Node3<T1,T2,T3,key>& right) {

  if (key == 0)
    return left.a > right.a;

  else if (key == 1)
    return left.b > right.b;

  else if (key == 2)
    return left.c > right.c;

  else
    return false;
};



template <class T1, class T2, class T3, int key>
bool operator==(const Node3<T1,T2,T3,key>& left, const Node3<T1,T2,T3,key>& right) {

  if (key == 0)
    return ( (left.b == right.b && left.c == right.c) || (left.c == right.b && left.b == right.c) );

  else if (key == 1)
    return ( (left.a == right.a && left.c == right.c) || (left.c == right.a && left.a == right.c) );
    
  else if (key == 2)
    return ( (left.b == right.b && left.a == right.a) || (left.a == right.b && left.b == right.a) );
    
  else
    return false;  
};*/

#endif

---