数据结构之线性表

#ifndef _LIST_H_
#define _LIST_H_

#include <iostream>
#include <cstdio>

namespace Linear{
    class FNode{
        public :
        //virtual operator <() = 0;
            virtual void print_node() = 0;
    };
    template<typename D>//给出合适的链表节点
    class List{
        typedef D* node;
        public:
            node head,tail;
            unsigned len;
            List *list;
        public:
            List()
            {
            	//this->List() = new List();
            	this->list = NULL;
                this->head = NULL;
                this->tail = NULL;
                this->len = 0;
            }

            ~List()
            {
                node tmp = head;
                if (head)
                {
                    while(head->next)
                    {
                        tmp = head;
                        head = head->next;
                        delete tmp;
                    }
                }
            }

            void clear()
            {
                node tmp = head;
                if (head)
                {
                    while(head->next)
                    {
                        tmp = head;
                        head = head->next;
                        delete tmp;
                    }
                }
                this->head = NULL;
                this->tail = NULL;
                this->len = 0;
            }

            bool empty()
            {
                return head == NULL;
            }

            void print_list()
            {
                //std::cout << "------" <<std::endl;
                node tmp = head;
                while(tmp)
                {
                    tmp->print_node();
                    tmp = tmp->next;//this->print_list();
                }
                std::cout << std::endl;
            }

            void insert(D elem)
            {
            	elem.next = NULL;
                node tmp = head;
                if (head == NULL)
                {

                    head = new D;
                    *head = elem;
                    tail = head;
                    head->next = tail->next = NULL;
                }
                else
                {
                    node fore = NULL;
                    while(tmp && elem > *tmp)
                    {
                        fore = tmp;
                        tmp = tmp->next;
                    }
                    if (fore == NULL)
                    {
                        fore = head;
                        head = new D;
                        *head = elem;
                        head->next = fore;
                    }
                    else {
                        if (tmp == NULL)
                        {
                            //elem.print_node();
                            fore->next = new D;
                            *fore->next = elem;
                            fore->next->next = NULL;
                            this->tail = fore->next;
                        }
                        else
                        {
                            node t = new D;
                            *t = elem;
                            t->next = tmp;
                            fore->next = t;
                        }
                    }
                }
                len++;
            }

            node get(unsigned index)
            {
                if (index < 0 || index >= len) return NULL;
                else
                {
                    node tmp = head;
                    for (unsigned i=1;i<=index;i++)
                    {
                        tmp = tmp->next;
                    }
                    return tmp;
                }
            }

            node nextElem(D elem)
            {
                node tmp = head;
                while(tmp && *tmp != elem) tmp = tmp->next;

                return tmp;
            }

            void unit(int num ,List &L ...)
            {
                List * ls = &L;

                for (int i=0;i<num;i++)
                {
                    if (head == NULL)
                    {
                        head = ls[i].head;
                        len = ls[i].len;
                        tail = ls[i].tail;
                    }
                    else {
                        node tmp = ls[i].head;
                        while(tmp)
                        {
                            insert(*tmp);
                            tmp = tmp->next;
                        }
                    }
                }
            }

            List copy()
            {
                return *this;
            }

            void merge(List L)
            {
            	if (list != NULL)
            		list->~List();
            	list = new List();
                List<D> &ls = *list;
                ls.clear();
                unsigned x = 0;
                unsigned y = 0;
                while(x < len && y < L.len)
                {
                    //std::cout << x << " " << y << std::endl;
                    node j = get(x);
                    node k = L.get(y);
                    node p = ((*j) > (*k) ? (y++,k ):(x++,j));
                    //(*p).print_node();
                    ls.insert(*p);
                }
                while(x < len) ls.insert(*get(x++));
                while(y < L.len) ls.insert(*L.get(y++));
                //ls.print_list();
                this->clear();
                this->unit(1,ls);
                //print_list();
            }

            bool elemdelete(unsigned index)
            {
                
                if (index < 0 || index >= len) return false;
                else
                {
                    unsigned i = 0;
                    node fore = NULL;
                    node tmp = head;
                    while(i<index)
                    {
                        i++;fore = tmp;tmp = tmp->next;
                    }
                    if(fore == NULL)
                    {
                        head = head->next;

                        delete tmp;
                    }
                    else
                    {
                        fore->next = tmp->next;

                        //(*tmp).print_node();
                        delete tmp;
                    }
                }
                len--;
                return true;
            }
    };
}
class node : public Linear::FNode
    {
        public:
            int data;
            virtual void print_node()
            {
                std::cout << data << std::endl;
            }
            node * next;
            node(int data):data(data){}
            node(){}
            
            bool operator > (node & x){
                return x.data < data;
            }
            bool operator == (node & x)
            {
                return x.data == data;
            }
            bool operator != (node & x)
            {
                return data != x.data;
            }
    };
int main()
{
    using namespace std;
    Linear::List<node> ls;
    node one(10);
    ls.insert(one);one.data = 18;
    ls.insert(one);
    ls.insert(node(2));
    Linear::List<node> lss;
    lss.insert(node(4));
    lss.insert(node(12));
    ls.merge(lss);
    //ls.unit(1,lss);
    std::cout << ls.len << std::endl;
    std::cout << std::endl;
    //cout << (*ls.head).data << endl;
    ls.elemdelete(1);std::cout << std::endl;
    cout << "------" << endl;
    ls.print_list();
}

#endif