List--C++模板类

#ifndef _PACKAGE_H_
#define _PACKAGE_H_

//数组实现
namespace list_in_array
{
template<typename T>
class List
{
private:
enum { bad = -1 };
enum { MAX = 100 };
T elements[MAX];
int last;
public:
List() { last = -1; };
~List() {}
void Insert(T x, int p);
void Delete(int p);
int Locate(T x)const;
T Retrieve(int p)const;
int Previous(int p)const;
int Next(int)const;
int MakeNull();
int First()const;
int End()const;
void Travel()const;
};
template<typename T>
void List<T>::Insert(T x, int p)
{
int q;
if (last >= MAX - 1)
cout << "FULL!\n";
else if ((p > last + 1) || (p < 0))
cout << "NOT EXIST!\n";
else
{
for (q = last; q >= p; q--)
elements[q + 1] = elements[q];
elements[p] = x;
last++;
}
}
template<typename T>
void List<T>::Delete(int p)
{
int q;
if ((p > last) || (p < 0))
cout << "NOT EXIST!\n";
else
{
for (q = p; q < last; q++)
elements[q] = elements[q + 1];
last--;
}
}
template<typename T>
int List<T>::Locate(T x)const
{
int q;
for (q = 0; q <= last; q++)
if (elements[q] == x)
return q;
cout << "NOT EXIST!\n";
return bad;
}
template<typename   T>
T List<T>::Retrieve(int p)const
{
if (p > last)
cout << "NOT EXIST!\n";
else
return elements[p];
return bad;
}
template<typename T>
int List<T>::Previous(int p)const
{
if (p<1 || p>last)
cout << "NOT EXIST!\n";
else
return p - 1;
return bad;
}
template<typename T>
int List<T>::Next(int p)const
{
if (p<0 || p>last - 1)
cout << "NOT EXIST!\n";
else
return p + 1;
return bad;
}
template<typename T>
int List<T>::MakeNull()
{
last = -1;
return 0;
}
template<typename T>
int List<T>::First()const
{
if (last < 0)
cout << "EMPTY!\n";
else
return 0;
return bad;
}
template<typename T>
int List<T>::End()const
{
if (last < 0)
cout << "EMPTY!\n";
else
return last;
return -1;
}
template<typename T>
void List<T>::Travel()const
{
for (int i = 0; i <= last; i++)
cout << elements[i] << endl;
}
}

//链表实现
namespace link_list
{
template<typename T>
class List
{
public:
struct Node
{
T data;
struct Node *next;
};
Node *head;
int length;
public:
List()
{
length = 0;
head = new Node{ 0,NULL };
}
~List() { delete head; }
void Insert(T x, Node *p);
void Delete(Node *p);
Node * Locate(T x)const;
T Retrieve(Node *p)const;
Node* Previous(Node *p)const;
Node* Next(Node *p)const;
Node* MakeNull();
Node* First()const;
Node* End()const;
void Travel()const;
};
template<typename T>
void List<T>::Travel()const
{
Node *t = head->next;
while (t != NULL)
{
cout << t->data << endl;
t = t->next;
}
}
template<typename T>
typename List<T>::Node* List<T>::End()const
{
Node *t = head;
while (t->next != NULL)
t = t->next;
return t;
}
template<typename T>
typename List<T>::Node* List<T>::First()const
{
return head;
}
template<typename T>
typename List<T>::Node* List<T>::MakeNull()
{
Node *t = head->next;
while (t != NULL)
{
Node *t2 = t;
t = t->next;
delete t2;
}
head->next = NULL;
length = 0;
return head;
}
template<typename T>
typename List<T>::Node* List<T>::Next(Node*p)const
{
if (p->next != NULL)
return p->next;
else
cout << "NOT EXIST!\n";
return p->next;
}
template<typename T>
typename List<T>::Node* List<T>::Previous(Node *p)const
{
Node *t;
if (p == head)
cout << "NOT EXIST!\n";
else
{
t = head;
while (t->next != p)
t = t->next;
return t;
}
}
template<typename T>
T List<T>::Retrieve(Node *p)const
{
return p->data;
}
template<typename T>
typename List<T>::Node* List<T>::Locate(T x)const
{
Node *t = head;
while (t != NULL)
if (t->data == x)
return t;
else
t = t->next;
return t;
}
template<typename T>
void List<T>::Delete(Node *p)
{
Node *t;
if (p->next != NULL)
{
t = p->next;
p->next = t->next;
delete t;
}
else
{
t = head;
while (t->next->next != NULL)
t = t->next;
delete t->next;
t->next = NULL;
}
length--;
}
template<typename T>
void List<T>::Insert(T x, Node *p)
{
Node *t = new Node;
t->data = x;
if (p->next != NULL)
{
t->next = p->next;
p->next = t;
}
else
{
p->next = t;
t->next = NULL;
}
length++;
}
}

//静态链表
namespace static_link_list
{
template<typename T>
class List
{
private:
struct Node
{
T data;
int next;
};
enum { maxsize = 100 };
Node space[maxsize];
int avail;
int GetNode();
void FreeNode(int q);
public:
List() {}
~List() {}
void Initialize();
void Insert(T x, int p);
void Delete(int p);
};
template<typename T>
void List<T>::Delete(int p)
{
int q;
if (space[p].next != -1)
{
q = space[p].next;
space[p].next = space[q].next;
FreeNode(q);
}
else
cout << "NOT EXIST!\n";
}
template<typename T>
void List<T>::Insert(T x, int p)
{
int q;
q = GetNode();
space[q].data = x;
space[q].next = space[p].next;
space[p].next = q;
}
template<typename T>
void List<T>::FreeNode(int q)
{
space[q].next = space[avail].next;
space[avail].next = q;
}
template<typename T>
int List<T>::GetNode()
{
int p;
if (space[avail].next == -1)
{
cout << "FULL!\n";
p = -1;
}
else
{
p = space[avail].next;
space[avail].next = space[p].next;
}
return p;
}
template<typename T>
void List<T>::Initialize()
{
int i;
for (i = 0; i < maxsize - 1; i++)
space[i].next = i + 1;
space[i].next = -1;
avail = 0;
}
}

//双向链表
namespace double_link_list
{
template<typename T>
class List
{
private:
struct Node
{
T data;
struct Node *next, *prior;
};
Node *head;
int length;
public:
List() { head = new Node{ 0,NULL,NULL }; }
~List() {}
void Insert(T x, Node*p);
void Delete(Node *p);
};
template<typename T>
void List<T>::Delete(Node *p)
{
if (p->prior != NULL)
p->prior->next = p->next;
if (p->next != NULL)
p->next->prior = p->prior;
delete p;
length--;
}
template<typename T>
void List<T>::Insert(T x, Node *p)
{
Node *s = new Node;
s->data = x;
s->prior = p;
s->next = p->next;
p->next->prior = s;
p->next = s;
length++;
}
}

//循环链表
namespace ring_link_list
{
template<typename T>
class List
{
private:
struct Node
{
T data;
struct Node *next;
};
Node *head;
public:
void LInsert(T x);
void RInsert(T x);
};
template<typename T>
void List<T>::RInsert(T x)
{
LInsert(x);
head = head->next;
}
template<typename T>
void List<T>::LInsert(T x)
{
Node *p = new Node;
p->data = x;
if (head == NULL)
{
p->next = p;
head = p;
}
else
{
p->next = head->next;
head->next = p;
}
}
}

//广义表
namespace general_list
{
template<typename T>
class List
{
private:
enum tag { ATOM, LIST };
struct Node
{
struct Node *link;
bool tag;
union
{
T data;
struct Node *dlink;
};
};
Node *head;
public:
bool Eaqual(List<T> &t)const;
};
template<typename T>
bool List<T>::Eaqual(List<T> &t)const
{
bool x, y;
y = false;
if (head == NULL && t.head == NULL)
y = true;
else if (head != NULL && t.head != NULL)
{
if (head->tag == t.head->tag)
{
if (head->tag == ATOM)
{
if (head->data == t.head->data)
x = true;
else
x = false;
if (x == true)
y = head->link.Eaqual(t.head->link);
}
else
{
x = head->dlink.Eaqual(t.head->dlink);
if (x == true)
y = head->link.Eaqual(t.head->link);
}
}
}
return y;
}
}

#endif