�� ṹ�㷨��---c++����ʵ��

������ �� ṹ��д���㷨���Ұ��������4�����ǻ��㷨������� ϰ����ʹ��c++���������ʽ��д�������㷨

����‫��װ�ڸ‬Ե�����������ӹ��

‫�����ܣ‬Ӧ��������Ӻ���ɡ��Ҷ����ͼ�Ĺ���Ҳ����һЩ���Ի���ƣ������

���� ������������
ܿ û��ϵ��4������� ʹ��ģ����ƣ����ԶԸ��������� ������Σ��ַ��

///////////////////////////
// //
// �� �� ṹ stack.h //
// //
//////////////////////////

#include<iostream.h>

template<class type>class stack;

template<class type>
class stacknode
{
friend class stack<type>;
private:
type data;
stacknode<type> *link;
stacknode(type d=0,stacknode<type> *l=null):link(l),data(d){}
};

template<class type>
class stack
{
public:
stack():top(null),numitem(0){}
void push(type item);
type pop();
type gettop();
void makeempty();
bool isempty();
int getnum();
private:
int numitem;
stacknode<type> *top;
};

template<class type>
void stack<type>::push(type item)
{
top=new stacknode<type>(item,top);
numitem++;
}

template<class type>
type stack<type>::pop()
{
stacknode<type> *p;
type temp;
temp=top->data;
p=top;
top=top->link;
delete p;
numitem--;
return temp;

template<class type>
type stack<type>::gettop()
{
return top->data;
}

template<class type>
bool stack<type>::isempty()
{
return top==null;
}

template<class type>
void stack<type>::makeempty()
{
delete top;
}

template<class type>
int stack<type>::getnum()
{
return numitem;
}

///////////////////////////
// //
// ������ ṹ queue.h //
// //
//////////////////////////
#include<iostream.h>

template<class type> class queue;

template<class type> class queuenode

{
friend class queue<type>;
private:
type data;
queuenode<type> *link;
queuenode(type d=0,queuenode *l=null):data(d),link(l){}
};

template <class type> class queue

{
public:
queue():rear(null),front(null){}
~queue();
void enqueue(type item);
type delqueue();
type getfront();
void makeempty();
bool isempty() { return front==null; }
private:
queuenode<type> *front,*rear;
};

template<class type>
queue<type>::~queue()
{
queuenode<type> *p;
while(front!=null)
{
p=front;
front=front->link;
delete p;
}
}

template<class type>
void queue<type>::enqueue(type item)
{
if(front==null)
front=rear=new queuenode<type> (item,null);
else
rear=rear->link=new queuenode<type> (item,null);
}

template<class type>
type queue<type>::delqueue()
{
queuenode<type> *p=front;
type temp=p->data;;
front=front->link;
delete p;
return temp;
}

template<class type>
type queue<type>::getfront()
{
return front->data;
}

template<class type>
void queue<type>::makeempty()
{
queuenode<type> *p;
while(front!=null)
{
p=front;
front=front->link;
delete p;
}
}

///////////////////////////
// //
// t���� ṹ list.h //
// //
//////////////////////////

#include<iostream.h>

template<class type>
class list;

template<class type>
class listnode
{
public:
friend class list<type>;
private:
type data;
listnode<type> * next;
};

template<class type>
class list
{
public:
list();
~list();
void insertend(type); //��t������� ��
bool insert(type,int); //��t������λ�ò��� ��
void delnode(int i); //ɾ�� ��
int find(type t); //���� ��
void makeempty(); //���t��
bool print(); //��ӡt��
int getlen(); //�õ�t���
private:
listnode<type> *first,*last;
int length;
};

template<class type>
void initlist(type &tmp);

template<class type>
void list_exit(list<type> &l,type tmp);

void initation();
template<class type>
void list_insertend(list<type> &l,type tmp);

template<class type> int list<type>::getlen()

{
return length;
}

template<class type> void list<type>::makeempty()

{
listnode<type> *p1,*p2;

p1=first->next;
first->next=null;
while(p1!=null)
{
p2=p1;
p1=p1->next;
delete p2;
}
length=0;
}

template<class type> void list<type>::insertend(type t)

{

listnode<type> *p;
p=new listnode<type>;
p->data=t;
p->next=null;
last->next=p;
last=p;

length++;
}

template<class type> bool list<type>::insert(type t,int i)

{
listnode<type> *p;
p=first;

int k=1;
while(p!=null&&k<i)
{
p=p->next;
k++;
}
if(p==null&&k!=i)
return false;
else
{
listnode<type> *tp;
tp=new listnode<type>;
tp->data=t;
tp->next=p->next;
p->next=tp;
 length++;

return true;
}
}

template<class type> void list<type>::delnode(int i)

{
int k=1;
listnode<type> *p,*t;
p=first;

while(p->next!=null&&k!=i)
{
p=p->next;
k++;
}
t=p->next;
cout<<"��� �������� "<<t->data<<"ɾ��"<<endl;

p->next=p->next->next;
length--;
delete t;
}

template<class type> bool list<type>::print()

{
listnode<type> *p=first->next;
if(length==0)
return false;
else
{
cout<<"t������"<<length<<"�����: "<<endl;
while(p)
{
cout<<p->data<<" ";
p=p->next;
}
}
cout<<endl;

return true;
}

template<class type> int list<type>::find(type t)

{
listnode<type> *p=first->next;
int i=1;
while(p&&p->data!=t)
{
p=p->next;
i++;
}
if(p)
return i;
else
return 0;
}

template<class type> list<type>::~list()

{
delete first;
cout<<"��ӭ�‫<<" )!^!( ��ʹ�ٴ‬endl;
}

template<class type> list<type>::list()

{
listnode<type> *node=new listnode<type>;
node->next=null;
first=last=node;
length=0;
}

///////////////////////////
// //
// ͼ�� ṹ graph.h //
// //
//////////////////////////

#include<iostream.h>
#include"queue.h"

template<class nametype,class distype>class graph;

template<class nametype,class distype> struct node

{
friend class graph<nametype,distype>;
int num;
distype val;
node<nametype,distype> *next;
};

template<class nametype,class distype> struct gpnode

{
friend class graph<nametype,distype>;
nametype data;
node<nametype,distype> *link;
};

template<class nametype,class distype>

class graph
{
public:
void creat(); //����ͼ
void printnode(); //��ӡͼ�еĸ�������
void dfs(); //ͼ�������������,����
void dfs(int v,int visited[]); // �ӹ��
void bfs(); //ͼ�Ĺ��������������
void bfs(int v,int visited[]); //�ӹ��
void shortpath(); //�����·��
private:
 gpnode<nametype,distype> *table;
node<nametype,distype> *p;
int numnode; //�‫����ڵ‬
};

template<class nametype,class distype>

void graph<nametype,distype>::creat()
{
do
{
cout<<"������‫����ڵ‬: ";
cin >> numnode;
}while(numnode<=0);

table=new gpnode<nametype,distype>[numnode];
cout<<"�������‫<<"������ڵ‬endl;
for(int i=0;i<numnode;i++)
{
cin>>table[i].data;
table[i].link=null;
}

cout<<"������� Ĺ�ϵ (��: a b)"<<endl;

i=1;
nametype nodea,nodeb;
bool finda,findb;
char isexit;
int m,n;
do
{
finda=findb=false;
cout<<"�������"<<i<<"� Ĺ�ϵ"<<endl;
cin>>nodea>>nodeb;
for(m=0,n=0;m<numnode&&n<numnode&&!(finda & findb);) //��� Ľ ‫�ڵ‬
{
if(nodea!=table[m].data)
m++;
else
finda=true;
if(nodeb!=table[n].data)
n++;
else
findb=true;

}
if(!(finda & findb))
cout<<"����Ľ ‫�������ڵ‬д���"<<endl;
else
{
p=new node<nametype,distype>;
p->next=table[m].link;
p->num=n;
 table[m].link=p;
cout<<"������ö �Ȩֵ: ";
cin>>p->val;
i++;
}
cout<<"� ��������: y)����,X)������˳� ";
cin>>isexit;
if(isexit!='y'&&isexit!='y')
break;

}while(true);

template<class nametype,class distype>

void graph<nametype,distype>::printnode()
{
cout<<"ͼ�и�‫ ������ڵ‬: ";
for(int i=0;i<numnode;i++)
cout<<table[i].data<<" ";
cout<<endl;
}

template<class nametype,class distype>

void graph<nametype,distype>::dfs()
{
int *visited=new int[numnode];
cout<<"ͼ������������� : ";
for(int i=0;i<numnode;i++)
visited[i]=0;
for(i=1;i<numnode;i++) //�����b�‫�ڵ‬
dfs(i,visited);
delete []visited;
cout<<endl;
}

template<class nametype,class distype>

void graph<nametype,distype>::dfs(int v,int visited[])
{
node<nametype,distype> *t;
if(visited[v]==0)
cout<<table[v].data<<" ";
visited[v]=1;
t=table[v].link;
while(t!=null)
{
if(visited[t->num]==0)
dfs(t->num,visited);
t=t->next;
}
}

template<class nametype,class distype>

void graph<nametype,distype>::bfs()
{
int *visited=new int[numnode];
cout<<"ͼ�Ĺ���������� : ";
for(int i=0;i<numnode;i++)
visited[i]=0;
for( i=0;i<numnode;i++)
bfs(i,visited);
}

template<class nametype,class distype>

void graph<nametype,distype>::bfs(int v,int visited[])
{
queue<int> q;
int n;
if(visited[v]==0)
{
visited[v]=1;
cout<<table[v].data<<" ";
q.enqueue(v);
while(!q.isempty())
{
n=q.delqueue();
p=table[n].link;
while(p!=null)
{
n=p->num;
if(visited[n]==0)
{
cout<<table[n].data<<" ";
visited[n]=1;

}
p=p->next;
}

}
}

///////////////////////////
// //
// �����㷨�� ṹ compositor.h //
// //
//////////////////////////

#include<iostream.h>

template<class type>
class compositor
{
public:
compositor():sort(null){}
 void creat(); //������������
void bubble(); //����
void insert(); //��������
//��������
void quick();
void qsort(int,int);
int partition(int low,int high);
//�鲢����
void merge(type sr[],type tr[],int i,int m,int n);
void msort(type sr[],type tr1[],int s,int t);
void mergesort();
//ѡ������
void select();
void print(); //��ӡ�����Ľ��
protected:
type *sort;
int leng;
};

template<class type>
void compositor<type>::creat()
{
cout<<"��������Ҫ������� ���: ";
cin>>leng;
while(leng<=0)
{
cout<<"�����������";
cin>>leng;
}
sort=new type[leng];
cout<<"����������� ";
for(int i=0;i<leng;i++)
cin>>sort[i];
}

template<class type>
void compositor<type>::insert()
{
creat();
type temp;
for(int i=1;i<leng;i++)
{
if(sort[i]<sort[i-1])
{
temp=sort[i];
for(int j=i-1;temp<sort[j]&&j>=0;j--)
{
sort[j+1]=sort[j];
}
sort[j+1]=temp;
}
}
print();

}
template<class type>
void compositor<type>::bubble()
{
creat();
type temp;
for(int i=leng-1;i>=0;i--)
{
for(int j=0;j<leng-1;j++)
{
if(sort[j]>sort[j+1])
{
temp=sort[j];
sort[j]=sort[j+1];
sort[j+1]=temp;
}
}
}
print();
}

template<class type>
void compositor<type>::quick()
{
creat();
qsort(0,leng-1);
print();
}

template<class type>
void compositor<type>::qsort(int s,int t)
{
if(s<t-1)
{
int pivotloc=partition(s,t);
qsort(s,pivotloc-1);
qsort(pivotloc+1,t);
}
}

template<class type>
int compositor<type>::partition(int low,int high)
{
type pivotkey=sort[low];
while(low < high)
{
while(low<high&&sort[high]>=pivotkey)
--high;
sort[low++]=sort[high];
while(low<high&&sort[low]<=pivotkey)
++low;
sort[high--]=sort[low];
}
sort[low]=pivotkey;
return low;
}

template<class type>
void compositor<type>::mergesort()
{
creat();
msort(sort,sort,0,leng-1);
print();
}

template<class type>
void compositor<type>::msort(type sr[],type tr1[],int s,int t)
{
int m;
type *tr2=new type[t-s];
if(s==t) tr1[s]=sr[s];
else
{
m=(t+s)/2;
msort(sr,tr2,s,m);
msort(sr,tr2,m+1,t);
merge(tr2,tr1,s,m,t);
}
}

template<class type>
void compositor<type>::merge(type sr[],type tr[],int i,int m,int n)
{
for(int j=m+1,k=i;i<=m&&j<=n;k++)
{
if(sr[i]<=sr[j])
tr[k]=sr[i++];
else
tr[k]=sr[j++];
}
while(i<=m)
tr[k++]=sr[i++];
while(j<=n)
tr[k++]=sr[j++];
}

template<class type>
void compositor<type>::select()
{
creat();
type temp;
int t;
for(int i=0;i<leng;i++)
{
t=i;
for(int j=i+1;j<leng;j++)
{
if(sort[t]>sort[j])
t=j;
}
if(t!=i)
{
temp=sort[t];
sort[t]=sort[i];
 sort[i]=temp;
}
}
print();
}

template<class type>
void compositor<type>::print()
{
cout<<"������Ϊ: ";
for(int i=0;i<leng;i++)
cout<<sort[i]<<" ";
cout<<endl;
}

///////////////////////////
// //
// �������� ṹ bintree.h //
// //
//////////////////////////

#include<iostream.h>

template<class type>class bintree;

template<class type>
class treenode
{
protected:
friend class bintree<type>;
treenode():lchild(null),rchild(null){}
type data;
treenode *lchild; //��������
treenode *rchild;
};

template<class type>
class bintree
{
friend void bintree_pre(bintree<type>& bintreeopp); //�� ����
friend void bintree_ino(bintree<type>& bintreeopp);
friend void bintree_pos(bintree<type>& bintreeopp);
friend void bintree_destroy(bintree<type>& bintreeopp);
public:
bintree():root(null){}
void creattree(); //����������,����
void creattree(treenode<type>* child,int k); //�ӹ��
void pretree(treenode<type> *point); //�����������
void inotree(treenode<type> *point); //�����������
void postree(treenode<type> *point); //�����������
void destroy(treenode<type> *point); //��‫�����ٶ‬
bool isempty();
protected:
 treenode<type>* root;
};

template<class type>
void bintree<type>::creattree()
{
creattree(root,1);
}

template<class type>
void bintree<type>::creattree(treenode<type>* child,int k)
{
treenode<type>* point;
point=new treenode<type>;
cout<<"����‫ ������ڵ‬:";
cin>>point->data;
switch(k)
{
case 1: root=point; break;
case 2: child->lchild=point;break;
case 3: child->rchild=point;break;
}

char temp;
cout<<"��"<<point->data<<"�‫ ��������� ��ڵ‬Y / ����� :";
cin>>temp;
if(temp=='y'||temp=='y')
{
creattree(point,2);
}

cout<<"��"<<point->data<<"�‫ ��������� ��ڵ‬Y / ����� :";

cin>>temp;
if(temp=='y'||temp=='y')
{
creattree(point,3);
}
}

template<class type>
void bintree<type>::pretree(treenode<type> *point)
{
if(point!=null)
{
cout<<" "<<point->data;
pretree(point->lchild);
pretree(point->rchild);
}
}

template<class type>
void bintree<type>::inotree(treenode<type> *point)
{
if(point!=null)
{

inotree(point->lchild);
cout<<" "<<point->data;
inotree(point->rchild);
}
}

template<class type>
void bintree<type>::postree(treenode<type> *point)
{
if(point!=null)
{

postree(point->lchild);
postree(point->rchild);
cout<<" "<<point->data;
}
}

template<class type>
bool bintree<type>::isempty()
{
return root==null;
}

template<class type>
void bintree<type>::destroy(treenode<type> *point)
{
if(point!=null)
{
destroy(point->lchild);
destroy(point->rchild);
delete point;
}
}

///////////////////////////
// //
// ������
ܺ basefun.h //
// //
//////////////////////////

void graph();
void list();
void stack();
void queue();
void compositor();
void bintree();

///////////////////////////
// //
// �� ������
ܺ stack.cpp/ /
// //
//////////////////////////

#include"stack.h"
#include"iostream.h"

const int int =13;

const double float= 13.33;
const char char ='a';

template<class type>
void stack_push(stack<type> &stackopp)
{
cout<<"������Ҫ����������: ";
type item;
cin>>item;
stackopp.push(item);
}

template<class type>
void stack_pop(stack<type> &stackopp)
{
if(!stackopp.isempty())
{
cout<<"�� �����: ";
cout<<stackopp.pop()<<endl;
}
else
{
cout<<"�� � ���!"<<endl;
}
}

template<class type>
void stack_isempty(stack<type> &stackopp)
{
if(!stackopp.isempty())
cout<<"�� ����,����"<<stackopp.getnum()<<"�����!"<<endl;
else
cout<<"�� ��!"<<endl;

template<class type>
void stack_gettop(stack<type> &stackopp)
{
if(!stackopp.isempty())
cout<<" �� ����"<<stackopp.gettop()<<endl;
else
cout<<"�� ��!"<<endl;
}

template<class type>
void stack_makeempty(stack<type> &stackopp)
{
if(!stackopp.isempty())
{
stackopp.makeempty();
cout<<"�� � ����!"<<endl;
}
else
{
cout<<"���ʧ��!"<<endl;
}
}

template<class type>
void stackini(type temp)
{
stack<type> stackopp;

do
{
cout<<"�� �IJ���: "<<endl
<<" 1) ����� "<<endl
<<" 2) �� "<<endl
<<" 3) �� � ���"<<endl
<<" 4) �� �������"<<endl
<<" 5) ��‫<<" �ٶ‬endl
<<" x) �˳�� ����"<<endl;
int item;
cin>>item;
switch(item)
{
case 1: stack_push(stackopp); break;
case 2: stack_pop(stackopp); break;
case 3: stack_isempty(stackopp); break;
case 4: stack_gettop(stackopp); break;
case 5: stack_makeempty(stackopp); break;

default: return ;
}

}while(true);

void stack()
{
int item;
cout<<"��ѡ���������: 1) ���� 2) ������ 3) �ַ��� X) �˳�: ";

cin>>item;
switch(item)
{
case 1: stackini(int); break; //�� �ͬ���û���Ҫѡ���������
case 2: stackini(float); break;
case 3: stackini(char); break;
default: return ; break;
}
}

///////////////////////////
// //
// �������
ܺ queue.h //
// //
//////////////////////////

#include"queue.h"

const int int =13;

const double float= 13.33;
const char char ='a';

template<class type>
void queue_enter(queue<type> &queueopp)
{
cout<<"������Ҫ������е����: ";
type item;
cin>>item;
queueopp.enqueue(item);
}

template<class type>
void queue_del(queue<type> &queueopp)
{
if(!queueopp.isempty())
{
cout<<"������:"<<queueopp.delqueue()<<endl;
}
else
{
cout<<"��������!"<<endl;
}
}

template<class type>
void queue_isempty(queue<type> &queueopp)
{
if(queueopp.isempty())
{
cout<<"����� �!"<<endl;
}
else
{
cout<<"�����!"<<endl;
}
}

template<class type>
void queue_getfront(queue<type> &queueopp)
{
if(!queueopp.isempty())
{
cout<<"�� ��Ϊ: "<<queueopp.getfront()<<endl;
}
else
{
cout<<"����� �!"<<endl;
}
}

template<class type>
void queue_makeempty(queue<type> &queueopp)
{
queueopp.makeempty();
cout<<"�������!"<<endl;
}

template<class type>
void queueini(type temp)
{
queue<type> queueopp;

do
{
cout<<"���еIJ���: "<<endl
<<" 1) �������"<<endl
<<" 2) ���"<<endl
<<" 3) ����� ���"<<endl
<<" 4) �ö� �����"<<endl
<<" 5) ��‫<<"���ٶ‬endl
<<" x) �˳���в���"<<endl;
int item;
cin>>item;
switch(item)
{
case 1: queue_enter(queueopp); break;
case 2: queue_del(queueopp); break;
case 3: queue_isempty(queueopp); break;
case 4: queue_getfront(queueopp); break;
case 5: queue_makeempty(queueopp); break;

default: return ;
}

}while(true);

}
void queue() //�� �ͬ���û���Ҫѡ���������
{
int item;
cout<<"��ѡ���������: 1) ���� 2) ������ 3) �ַ��� X) �˳�: ";

cin>>item;
switch(item)
{
case 1: queueini(int); break;
case 2: queueini(float); break;
case 3: queueini(char); break;
default: return ; break;
}
}

///////////////////////////
// //
// t�� list.h //
// //
//////////////////////////

#include"list.h"
#include<iostream.h>
#include<stdlib.h>

template<class type>
void initlist(type &tmp)
{
list<type> list;
int n;

while(true)
{

cout<<"��ѡ����Ҫ��t����еIJ��� "<<endl
<<"1) ��ĩβ�������"<<endl
<<"2) ����� �������"<<endl
<<"3) ɾ�������"<<endl
<<"4) ɾ�����t��"<<endl
<<"5) ��ӡt��"<<endl
<<"6) ���������"<<endl
<<"7) �˳�"<<endl;

cout<<">\\ ";
cin>>n;

while(n<1||n>7)
{
cout<<"�����������������!"<<endl;
cout<<">\\ ";
cin>>n;
}
switch(n)
{
case 1: list_insertend(list);break;
case 2: list_insert(list);break;
case 3: list_delnode(list);break;
case 4: list_makeempty(list);break;
case 5: list_print(list);break;
case 6: list_find(list);break;
case 7: return ;break;
}

void list()
{
int n;
cout<<"��ѡ����Ҫ�����t���������� 1)��� �2) ַ���,3)������"<<endl;
cout<<">\\ ";
cin>>n;

while(n<1||n>3)
{
cout<<"�����������������!"<<endl;
cout<<">\\ ";
cin>>n;
}

char t_c='c';
int t_i=12;
double t_f=23.3;

switch(n)
{
case 1:initlist(t_i);break;
case 2:initlist(t_c);break;
case 3:initlist(t_f);break;
}
}

template<class type>
void list_insertend(list<type> &l)
{
type t;
cout<<"������������: >\\";
cin>>t;
l.insertend(t);
}

template<class type>
void list_find(list<type> &l)
{
type t;
cout<<"��������Ҫ��� ����� >\\ ";
cin>>t;
int i;
if(!(i=l.find(t)))
cout<<"��Ҫ��� ����� ����!"<<endl;
else
cout<<"��Ҫ��� �������‫<<"�ڵ‬i<<"��λ��"<<endl;
}

template<class type>
void list_insert(list<type> &l)
{

type t;
cout<<"������������: >\\";
cin>>t;

int n;
cout<<"����������: >\\";
cin>>n;
if(l.insert(t,n))
cout<<"����ɹ�! ��"<<n<<"λ�� ����"<<t<<endl;
else
cout<<"����ʧ��! ����λ�ò���ȷ!"<<endl;

template<class type>
void list_delnode(list<type>& l)
{
int i;
cout<<"������Ҫɾ��������λ��: >\\";
cin>>i;

while(i<1||i>l.getlen())
{
cout<<"������� �����
ܴ t���,���������!"<<endl;
cout<<">\\ ";
cin>>i;
}

l.delnode(i);
}
template<class type>
void list_makeempty(list<type> &l)
{
l.makeempty();
}

template<class type>
void list_print(list<type> &l)
{
if(!l.print())
cout<<"t����!"<<endl;
}
///////////////////////////
// //
// ͼ������
ܺ graph.h //
// //
//////////////////////////

#include"graph.h"

template<class nametype,class distype>

void graph_creat(graph<nametype,distype> &graphopp)
{
graphopp.creat();
}

template<class nametype,class distype>

void graph_dfs(graph<nametype,distype> &graphopp)
{
graphopp.dfs();
}

template<class nametype,class distype>

void graph_bfs(graph<nametype,distype> &graphopp)
{
graphopp.bfs();
}

template<class nametype,class distype>

void graph_print(graph<nametype,distype> &graphopp)
{
graphopp.printnode();
}

void graph()
{
graph<char,int> graphopp;
do
{
cout<<"ͼ�IJ���: "<<endl
<<" 1) ��bͼ"<<endl
<<" 2) ͼ�������������"<<endl
<<" 3) ͼ�Ĺ����������"<<endl
<<" 4) ��ӡͼ�и���"<<endl
<<" x) �˳��������"<<endl;
int item;
cin>>item;
switch(item)
{
case 1: graph_creat(graphopp); break;
case 2: graph_dfs(graphopp); break;
case 3: graph_bfs(graphopp); break;
case 4: graph_print(graphopp); break;
default: return ;
}
}while(true);

///////////////////////////
// //
// �����㷨������
ܺ compositor.cpp //
// //
//////////////////////////

#include"compositor.h"

const int int =13;

const double float= 13.33;
const char char ='a';

template<class type>
void compositorini(type temp)
{
compositor<type> compositoropp;

do
{
cout<<"����IJ���: "<<endl
<<" 1) ��������"<<endl
<<" 2) ��������"<<endl
<<" 3) �鲢����"<<endl
<<" 4) ����"<<endl
<<" 5) ѡ������"<<endl
<<" x) �˳��������"<<endl
<<"��ѡ����Ӧ�IJ���: ";
int item;
cin>>item;
switch(item)
{
case 1: compositor_insert(compositoropp); break;
case 2: compositor_quick(compositoropp); break;
case 3: compositor_merge(compositoropp); break;
case 4: compositor_bubble(compositoropp); break;
case 5: compositor_select(compositoropp); break;

default: return ;
}

}while(true);

void compositor()//�� �ͬ���û���Ҫѡ���������

{
int item;
cout<<"��ѡ���������: 1) ���� 2) ������ 3) �ַ��� X) �˳�: ";

cin>>item;
switch(item)
{
case 1: compositorini(int); break;
case 2: compositorini(float); break;
case 3: compositorini(char); break;
default: return ; break;
}
}

template<class type>
void compositor_insert(compositor<type> compositoropp)
{
compositoropp.insert();
}

template<class type>
void compositor_quick(compositor<type> compositoropp)
{
compositoropp.quick();
}

template<class type>
void compositor_select(compositor<type> compositoropp)
{
compositoropp.select();
}

template<class type>
void compositor_merge(compositor<type> compositoropp)
{
compositoropp.mergesort();
}

template<class type>
void compositor_bubble(compositor<type> compositoropp)
{
compositoropp.bubble();
}

///////////////////////////
// //
// ����������
ܺ bintree.cpp//
// //
//////////////////////////

#include<iostream.h>
#include"bintree.h"

const int int =13;

const double float= 13.33;
const char char ='a';

template<class type>
void bintree_creat(bintree<type>& bintreeopp)
{
bintreeopp. creattree();
}

template<class type>
void bintree_pre(bintree<type>& bintreeopp)
{
if(!bintreeopp.isempty())
{
cout<<"����������� : ";
bintreeopp. pretree(bintreeopp.root);
}
else
{
cout<<"������� ���!"<<endl;
}
}

template<class type>
void bintree_ino(bintree<type>& bintreeopp)
{
if(!bintreeopp.isempty())
{
cout<<"����������� : ";
bintreeopp. inotree(bintreeopp.root);
}
else
{
cout<<"������� ���!"<<endl;
}

template<class type>
void bintree_pos(bintree<type>& bintreeopp)
{
if(!bintreeopp.isempty())
{
cout<<"����������� : ";
bintreeopp. postree(bintreeopp.root);
}
else
{
cout<<"������� ���!"<<endl;
}
}

template<class type>
void bintree_destroy(bintree<type>& bintreeopp)
{
bintreeopp.destroy(bintreeopp.root);
bintreeopp.root=null;
cout<<"������� ����!"<<endl;
}

template<class type>
void bintree_thread(bintree<type>& bintreeopp)
{
if(bintreeopp.isthread())
{
cout<<"�ö������ �����!!"<<endl;
}
else
{
bintreeopp.threadtree();
}
}

template<class type>
void bintree_through(bintree<type>& bintreeopp)
{
bintreeopp.through();
}

template<class type>
void bintreeini(type temp)
{
bintree<type> bintreeopp;

do
{
cout<<"��IJ���: "<<endl
<<" 1) ��������"<<endl
<<" 2) �����������"<<endl
<<" 3) �����������"<<endl
<<" 4) �����������"<<endl
<<" 5) ��‫<<" �����ٶ‬endl
<<" x) �˳��������"<<endl;
int item;
cin>>item;
switch(item)
{
case 1: bintree_creat(bintreeopp); break; //��������
case 2: bintree_pre(bintreeopp); break; //�����������
case 3: bintree_ino(bintreeopp); break; //�����������
case 4: bintree_pos(bintreeopp); break; //�����������
case 5: bintree_destroy(bintreeopp);break; //��������
default: return ;
}

}while(true);

void bintree()
{
int item;
cout<<"��ѡ���������: 1) ���� 2) ������ 3) �ַ��� X) �˳�: ";

cin>>item;
switch(item)
{
case 1: bintreeini(int); break; //�� �ͬ���û���Ҫѡ���������
case 2: bintreeini(float); break;
case 3: bintreeini(char); break;
default: return ; break;
}
}

///////////////////////////
// //
// ���� index.cpp �û�� � //
// //
//////////////////////////

#include <iostream.h>
#include"basefun.h"

void main()
{
//���ܲ �
do
{
cout<<"��ӭʹ���� ṹ�㷨��"<<endl
<<"1) ��� � "<<endl
<<"2) �� "<<endl
<<"3) ���� "<<endl
<<"4) ������ "<<endl
<<"5) ͼ "<<endl
<<"6) �����㷨 "<<endl

<<"7) �ַ� "<<endl

<<"x) ��������˳� "<<endl;
cout<<" ����ѡ������� ṹ�IJ���"<<endl;
int kind;
cin>>kind;
switch(kind)
{
case 1: list(); break;
case 2: stack(); break;
case 3: queue(); break;
case 4: bintree(); break;
case 5: graph(); break;
case 6: compositor(); break;
default: return;
}
}while(true);
}