C++ 代码重用 02-- 链表 19.9.数据类Data~19.14.头节点类中间节点类和尾节点类

#include <iostream>
using namespace std;
/*---------------------------------
1）链表由标签类、头结点、中间节点和尾节点组成
2）标签中保存着头结点的地址、头结点的next指针指向中间节点，中间节
   点的next指向下一个中间节点或者尾节点
3）头结点和尾节点都不保存数据，只有中间节点保存数据
4）头结点的作用是创建尾节点，并将数据传递给尾节点，
5）由尾节点创建一个中间节点，并由中间节点保存数据
---------------------------------*/
enum {small,large,same};         //枚举类型 形式1
//enum result{small,large,same}; //枚举类型 形式2
//typedef enum {small,large,same}result; //枚举类型 形式3
/*数据类*/
class date
{
public:
	date(int i):da(i){}
	~date(){}
	int compare(const date&);
	void print(){cout<<da<<endl;}
private:
	int da;
};
int date::compare(const date& x)
{
	if(da<x.da)
		return small;
	else if(da>x.da)
		return large;
	else
		return same;
}


/*节点类*/
class node
{
public:
	node(){}
	virtual ~node(){}
	virtual node* insert(date* one)=0;
	virtual void print()=0;
};


/*中间结点类*/
class insertnode:public node
{
public:
	insertnode(date* one, node* nx);
	~insertnode()
	{  
		delete next;//给中间节点类增加析构函数销毁尾节点
		delete thisdate;//销毁中间节点的数据对象
	}
	virtual node* insert(date* one);//抽象类的纯虚函数必须为子类定以后才能使用，所以，还得为中间节点定义insert
	virtual void print()
	{
		thisdate->print();//输出本节点的数据
		next->print();    //输出下一个节点的数据
	}
private:
	date* thisdate; //指向数据类的指针
	node* next;     //指向下一个中间节点或者向尾节点的指针
};
insertnode::insertnode(date* one, node* nx):thisdate(one),next(nx)
{
	cout<<"构造中间结点类insertnode并插入赋值数据..."<<endl;
}
node* insertnode::insert(date* one)
{
	cout<<"中间结点类insertnode插入数据"<<endl;
#if 0
	/*新的中间节点从尾结点前，即链表后端插入*/
	next=next->insert(one);//遍历递归调用，直到遇见尾节点，方可创建新的中间节点并存放数据
	return this;//返回本中间节点地址，以便上一个节点的next域记住该节点
#else
	/*新的中间节点从头结点后，即链表前端插入*/
	//insertnode* datenode =new insertnode(one,this);
	//return datenode; //返回本中间节点地址，以便上一个节点的next域记住该节点	
	if(one->compare(*thisdate) != large)
	{
		/*新的中间节点从头结点后，即链表前端插入*/
		insertnode* datenode =new insertnode(one,this);
		return datenode; //返回本中间节点地址，以便上一个节点的next域记住该节点
	}
	else
	{ 
		next=next->insert(one);//如果下个节点是尾节点，则调用尾节点的insert()函数
		return this;
	}
#endif
}


/*尾结点类*/
class tailnode:public node
{
public:
	tailnode(){cout<<"构造尾结点类tailnode..."<<endl;}
	//由于尾节点是最后一个节点，故不需要重写析构函数
	virtual node* insert(date* one);
	virtual void print(){}//尾节点无数据，执行空语句
};
node* tailnode::insert(date* one)
{
	cout<<"尾结点类tailnode插入数据"<<endl;
	insertnode* datenode =new insertnode(one,this);//one:数据的地址  this:tailnode类节点的地址
	                         //子类对象指针赋给父类指针
	return datenode;
}


/*头结点类*/
class headnode:public node
{
public:
	headnode();
	~headnode(){delete next;}//销毁中间节点
	virtual node* insert(date* one);
	virtual void print(){next->print();}
private:
	node* next;
};
headnode::headnode()
{
	cout<<"构造头结点类headnode..."<<endl;
	next=new tailnode;
}
node* headnode::insert(date* one)
{
	cout<<"头结点类headnode插入数据"<<endl;
	next =next->insert(one);//尾节点类insert函数返回中间节点的地址赋给头结点的next域
	return this;
}


/*    标签类
1) 创建头结点,并用一个指针指向它
2) 利用头结点的插入函数将数据插入到头结点
3) 利用头结点的输出函数输出该节点保存的数据
4) 删除头结点
*/
class label
{
public:
	label();
	~label(){delete head;}
	void insert(date* one);	//头结点插入数据
	void printall(){head->print();}
private:
	headnode *head;
};
label::label()
{
	cout<<"构造标签类label..."<<endl;
	head=new headnode;
}
void label::insert(date* one)
{
	cout<<"标签类label插入数据"<<endl;
	head->insert(one);//head指向node类下派生类headnode的对象,insert()是其成员函数
}




int main()
{
	date* pdate;
	int val;
	label ll;
	while(1)
	{
		cout<<"请输入值(0表结束)：";
		cin>>val;
		if(!val)
			break;
		pdate=new date(val);
		ll.insert(pdate);
	}
	ll.printall();
	return 0;
}

运行结果：
构造标签类label...
构造头结点类headnode...
构造尾结点类tailnode...
请输入值(0表结束)：6
标签类label插入数据
头结点类headnode插入数据
尾结点类tailnode插入数据
构造中间结点类insertnode并插入赋值数据...
请输入值(0表结束)：3
标签类label插入数据
头结点类headnode插入数据
中间结点类insertnode插入数据
构造中间结点类insertnode并插入赋值数据...
请输入值(0表结束)：5
标签类label插入数据
头结点类headnode插入数据
中间结点类insertnode插入数据
中间结点类insertnode插入数据
构造中间结点类insertnode并插入赋值数据...
请输入值(0表结束)：9
标签类label插入数据
头结点类headnode插入数据
中间结点类insertnode插入数据
中间结点类insertnode插入数据
中间结点类insertnode插入数据
尾结点类tailnode插入数据
构造中间结点类insertnode并插入赋值数据...
请输入值(0表结束)：4
标签类label插入数据
头结点类headnode插入数据
中间结点类insertnode插入数据
中间结点类insertnode插入数据
构造中间结点类insertnode并插入赋值数据...
请输入值(0表结束)：0
3
4
5
6
9
Press any key to continue