Организовать представление множеств в виде линейных однонаправленных списков

#include <iostream>
#include <cstdlib>
 
//итератор только для чтение.
template<class N, class T>
class lsiter {
private:
    N* p;
public:
    lsiter(void):p(NULL){}
    lsiter(N* _p):p(_p){}
public:
    bool operator != (const N* _p) const {
        return (p != _p);
    }
    bool operator == (const N* _p) const {
        return (p == _p);
    }
    lsiter& operator ++ (void){
        p = p->next;
        return *this;
    }
    lsiter operator ++ (int){
        lsiter it(*this);
        ++*this;
        return it;
    }
    const T& operator *(void) const { return p->val; }
};
 
//множество на базе односвязного списка
template<class T>
class lset {
    struct node {
        T     val;
        node* next;
    };
private:
    node* hl, *tl;
public:
    typedef lsiter<const node, const T> position;
 
    lset(void):hl(NULL), tl(NULL){}
    lset(const T* f, const T* l):hl(NULL), tl(NULL){
        copy(f, l);
    }
    lset(const lset&);
    ~lset(){
        this->clear();
    }
 
    lset& operator = (const lset&);
public:
    //вставка
    bool insert(const T& val){
        node* p, *a = hl, *b = hl;
 
        if((tl != NULL) && (val > tl->val)){
            if((p = _new_node(val)) != NULL){
                tl->next = p;
                tl = p;
            }
        } else {
            while((b != NULL) && (val >= b->val)){
                if(val == b->val)
                    return false;
                a = b;
                b = b->next;
            }
 
            p = _new_node(val);
            if(p == NULL)
                return false;
 
            if(hl == NULL)
                hl = tl = p;
            else if(hl == b){
                p->next = hl;
                hl = p;
            } else {
                a->next = p;
                p->next = b;
            }
        }
        return true;
    }
 
    //копировать массив
    void copy(const T* f, const T* l){
        clear();
        while(f != l)
            insert(*f++);
    }
 
    //удаление всех
    void clear(void){
        node* t;
        while(hl != NULL){
            t  = hl;
            hl = hl->next;
            delete t;
        }
        tl = NULL;
    }
 
    //Проверить, включено ли множество А во множество В.
    bool is_subset(const lset& a) const {
        const node* p1 = hl;
        const node* p2 = a.hl;
        while((p1 != NULL) && (p2 != NULL)){
            if(p1->val < p2->val)
                p1 = p1->next;
            else if(p2->val < p1->val)
                break;
            else {
                p1 = p1->next;
                p2 = p2->next;
            }
        }
        return (a.hl != NULL) && (p2 == NULL);
    }
 
    //Найти пересечение множеств А и В.
    static void intersect_s(const lset& a, const lset& b, lset& c){
        const node* p1 = a.hl;
        const node* p2 = b.hl;
        while((p1 != NULL) && (p2 != NULL)){
            if(p1->val < p2->val)
                p1 = p1->next;
            else if(p2->val < p1->val)
                p2 = p2->next;
            else {
                c.insert(p1->val);
                p1 = p1->next;
                p2 = p2->next;
            }
        }
    }
 
    //Найти объединение множеств А и В.
    static void union_s(const lset& a, const lset& b, lset& c){
        const node* p1 = a.hl;
        const node* p2 = b.hl;
        c.clear();
        while((p1 != NULL) && (p2 != NULL)){
            if(p1->val < p2->val){
                c.insert(p1->val);
                p1 = p1->next;
            } else if(p2->val < p1->val){
                c.insert(p2->val);
                p2 = p2->next;
            } else {
                c.insert(p1->val);
                p1 = p1->next;
                p2 = p2->next;
            }
        }
 
        for(; p1 != NULL; p1 = p1->next)
            c.insert(p1->val);
        for(; p2 != NULL; p2 = p2->next)
            c.insert(p2->val);
    }
 
    position begin(void) const { return hl; }
    bool empty(void) const { return (hl == NULL); }
private:
 
    node* _new_node(const T& val){
        node* p = new (std::nothrow) node();
        if(p != NULL){
            p->val  = val;
            p->next = NULL;
        }
        return p;
    }
};
 
 
int main(void){
    int a[] = { 1, 5, 9  };
    lset<int> A(a, a + sizeof(a)/sizeof(a[0]));
    
    int b[] = { 1, 3, 5, 7, 9};
    lset<int> B(b, b + sizeof(b)/sizeof(b[0]));
 
    if(B.is_subset(A))
        std::cout << "Yes." << std::endl;
    std::cout << std::endl;
    A.clear();
    B.clear();
 
    //...
 
    for(int i = 0; i < 7; ++i){
        A.insert(rand() % 10);
        B.insert(rand() % 10);
    }
 
    lset<int> C;
    lset<int>::intersect_s(A, B, C);
    
    std::cout << "A: ";
    for(lset<int>::position ia = A.begin(); ia != NULL; ++ia)
        std::cout << *ia << ' ';
    std::cout << std::endl;
 
    std::cout << "B: ";
    for(lset<int>::position ib = B.begin(); ib != NULL; ++ib)
        std::cout << *ib << ' ';
    std::cout << std::endl;
 
    std::cout << "INTERSECT: ";
    for(lset<int>::position ic = C.begin(); ic != NULL; ++ic)
        std::cout << *ic << ' ';
    std::cout << std::endl;
 
    //...
 
    C.clear();
    lset<int>::union_s(A, B, C);
    std::cout << "UNION: ";
    for(lset<int>::position k = C.begin(); k != NULL; ++k)
        std::cout << *k << ' ';
    C.clear();
    return 0;
}