#include<iostream.h>

template<class Type>
struct nodeType
{??
?Type info;
?nodeType<Type>? *link;
?nodeType<Type>? *back;
};

template<class Type>
class doublelist
{
public:
?doublelist();
?// doublelist(const doublelist<Type>& otherlist);
?const doublelist<Type>&operator=(const doublelist<Type>&otherlist);

?virtual ~doublelist();

?void initializelist();
??? void destory();

?bool isEmptylist();
?void print();
?void rprint();
?int? length();

??? void insertItem(const Type& insertItem);
?void deleteItem(const Type& deleteItem);

private:
??? nodeType<Type>? *first;
};

template<class Type>
const doublelist<Type>& doublelist<Type>::operator=(const doublelist<Type>& otherlist)
{??
??? if(first != NULL)
?{?
??destory();
?}

?if(this != &otherlist)
?{?
??if(otherlist.first == NULL)
??{
???first = NULL;
??}
??else
??{??
???nodeType<Type>* pointer = otherlist.first;
???nodeType<Type>* this_pointer = first;
???
??????????? while( pointer != NULL )
???{
????nodeType<Type>* newNode = new nodeType<Type>;
????newNode->info = pointer->info;
????newNode->link = NULL;
????newNode->back = NULL;

????if( this_pointer == NULL )
????{
?????this_pointer = first = newNode;
?????newNode->back = NULL;
?????newNode->link = NULL;
????}
????else
????{
?????newNode->back = this_pointer;
?????newNode->link = NULL;

?????this_pointer->link = newNode;
?????this_pointer = this_pointer->link;
????}????????
????
????pointer = pointer->link;
???}???
??}
?}

?return *this;
}

template<class Type>
doublelist<Type>::~doublelist()
{
?nodeType<Type>? *temp;
???
?while( first != NULL)
?{??
??temp? = first;
??first = first->link;
??delete temp;
?}
?
?//cout<<"析構函數被調用"<<endl;
}

template<class Type>
doublelist<Type>::doublelist()
{????
?first = NULL;
}

template<class Type>
void doublelist<Type>::initializelist()
{?
?doublelist<Type>::destory();
}

template<class Type>
bool doublelist<Type>::isEmptylist()
{?
?return(first == NULL);
}

template<class Type>
void? doublelist<Type>::destory()
{
?nodeType<Type> *temp;
?
?while( first != NULL)
?{
??temp? = first;
??first = first->link;
??delete temp;
?}
}

template<class Type>
void doublelist<Type>::print()
{?
?nodeType<Type> *current;
?current=first;
?while(current!=NULL)
?{
??cout<<current->info<<" ";
??????? current=current->link;
?}
}

template<class Type>
void doublelist<Type>::rprint()
{?
?nodeType<Type> *current = first;
?while(current!=NULL && current->link!= NULL)
??current = current->link;

?while(current!=NULL)
?{
??cout<<current->info<<" ";
??????? current=current->back;
?}
}

template<class Type>
int doublelist<Type>::length()
{??
?int count=0;
?nodeType<Type> *current;
?current=first;
?while(current!=NULL)
?{
??count++;
??current=current->link;
?}
?return count;
}

template<class Type>
void doublelist<Type>::insertItem(const Type& insertItem)
{
?nodeType<Type>* pointer = first;
?bool bFind = false;

?while( pointer != NULL )
?{
??if( pointer->info == insertItem )
??{
???bFind = true;
???break;
??}
??else
??{
???pointer = pointer->link;
??}
?}

?if( bFind )
?{
??cout << insertItem << " have already exist!!" << endl;
?}
?else
?{
??nodeType<Type>* newnode = new nodeType<Type>();

??if( first == NULL )
??{
???first = newnode;
????? newnode->back = NULL;
??}
??else
??{
???pointer = first;
???while( pointer->link != NULL )
????pointer = pointer->link;

???pointer->link = newnode;
???newnode->back = pointer;
??}

??newnode->link = NULL;
??newnode->info = insertItem;
?}
}

void main()
{
?doublelist<int> b,c;
?
?int num = 0, i = 0, j = 0;
?cout<<"please input the count of number:"<<endl;
?cin>>num;

?while(i < num)
?{
??cout<<"please input the number:";
??cin >> j;
??cout<<endl;
??b.insertItem(j);
??i++;
?}

?cout << "b normal: ";
??? b.print();
?cout << endl;

?c=b;
?
?cout << "normal: ";
?c.print();
?cout << endl;
?
?cout << "not normal: ";
?c.rprint();
?cout << endl;
}