1.用数组实现
#include<iostream>
#include "utility.h"
using namespace std;
const int max_list = 5000;
template <class List_entry> //模板
class List {
public:
List(); //构造函数
int size() const; //返回线性表的大小
bool full() const; //判满
bool empty() const; //判空
void clear(); //清空
void traverse(void (*visit)(List_entry &)); //遍历
Error_code retrieve(int position, List_entry &x) const; //读取指定位置的数据
Error_code replace(int position, const List_entry &x); //换掉指定位置的数据
Error_code remove(int position, List_entry &x); //删除指定位置的数据
Error_code insert(int position, const List_entry &x); //在指定位置插入数据
protected:
int count; //记数
List_entry entry[max_list]; //数组,存放数据
};
template <class List_entry>
List<List_entry>::List() //构造函数
{
count = 0;
}
template <class List_entry>
void List<List_entry>::clear() //清空
{
count = 0;
}
template <class List_entry>
int List<List_entry>::size() const //返回线性表的大小
{
return count;
}
template <class List_entry>
bool List<List_entry>::empty() const //判空
{
return count <= 0;
}
template <class List_entry>
bool List<List_entry>::full() const //判满
{
return count >= max_list;
}
template <class List_entry>
Error_code List<List_entry>::insert(int position, const List_entry &x) //在指定位置插入数据
{
if (full())
return overflow; //判断能否再插入数据
if (position < 0 || position > count) //判断指定位置是否合法
return range_error;
for (int i = count - 1; i >= position; i--)
entry[i + 1] = entry[i];//从指定位置开始往后,每一个数据向后移一位
entry[position] = x; //给指定位置赋值
count++; //计数器加一
return success;
}
template <class List_entry>
Error_code List<List_entry>::retrieve(int position,List_entry &x) const //读取指定位置的数据
{
if((position < 0) || (position >= count)) return range_error; //判断指定位置是否合法
x = entry[position]; //将指定位置元素赋给x
return success;
}
template <class List_entry>
Error_code List<List_entry>::replace(int position,const List_entry &x) //换掉指定位置的数据
{
if((position < 0) || (position >= count)) return range_error; //判断指定位置是否合法
entry[position] = x;//将指定位置元素换成x
return success;
}
template <class List_entry>
Error_code List<List_entry>::remove(int position,List_entry &x) //删除指定位置的数据
{
if(count == 0) return underflow; //判断是否有数据
if((position < 0) || (position >= count)) return range_error; //判断指定位置是否合法
x = entry[position]; //将这个位置的值取出赋给x
for(int i = position+1;i <= count - 1;i++)
{
entry[i - 1] = entry[i]; //从position+1往后每个数据都向前挪一个位置
}
count--; //计数器减一
return success;
}
template <class List_entry>
void List<List_entry>::traverse(void (*visit)(List_entry &)) //遍历。参数*visit指向任意一个无参函数,意思是将线性表中的每一项传给函数供函数使用
{
for (int i = 0; i < count; i++)
(*visit)(entry[i]);
}
2.用链表实现
#include<iostream>
#include "utility.h"
using namespace std;
template <class Node_entry>
struct Node {
Node_entry entry;
Node<Node_entry> *next;
Node(); //构造函数
Node(Node_entry data, Node<Node_entry> *link = NULL);
};
template <class Node_entry>
Node<Node_entry>::Node()
{
next = NULL;
}
template <class Node_entry>
Node<Node_entry>::Node(Node_entry data,Node<Node_entry> *link)
{
entry = data;
next = link;
}
template <class List_entry>
class List {
public:
List(); //构造函数
int size() const; //返回线性表的大小
bool full() const; //判满
bool empty() const; //判空
void clear(); //清空
void traverse(void (*visit)(List_entry &)); //遍历
Error_code retrieve(int position, List_entry &x) const; //读取指定位置的数据
Error_code replace(int position, const List_entry &x); //换掉指定位置的数据
Error_code remove(int position, List_entry &x); //删除指定位置的数据
Error_code insert(int position, const List_entry &x); //在指定位置插入数据
~List(); //析构函数
List(const List<List_entry> ©); //拷贝构造函数
void operator =(const List<List_entry> ©); //“=”运算符重载
protected:
int count; //计数器
Node<List_entry> *head; //头指针
Node<List_entry> *set_position(int position) const; //让指针指向指定位置
};
template <class List_entry>
List<List_entry> ::List() //构造函数
{
count = 0; //计数器置0
head = NULL;
}
template <class List_entry>
void List<List_entry>::clear() //清空
{
Node<List_entry> *p,*q;
for(p = head;p;p = q)
{
q = p->next;
delete p;
} //遍历,有数据的释放空间
count = 0;
head = NULL; //置空
}
template <class List_entry>
int List<List_entry>::size() const //返回线性表大小
{
return count;
}
template <class List_entry>
bool List<List_entry>::empty() const //判空
{
return count <= 0;
}
template <class List_entry>
bool List<List_entry>::full() const //判满
{
return false;
}
template <class List_entry>
void List<List_entry>::traverse(void (*visit)(List_entry &)) //遍历。参数*visit指向任意一个无参函数,意思是将线性表中的每一项传给函数供函数使用
{
Node<List_entry> *q;
for(q = head;q;q = q->next) (*visit)(q->entry); //将每个值都以引用形式传回
}
template <class List_entry>
Error_code List<List_entry>::insert(int position, const List_entry &x) //在指定位置插入数据
{
if (position < 0 || position > count) return range_error; //判断指定位置是否合法
Node<List_entry> *new_node, *previous, *following;
if (position > 0) //如果指定位置不是表头
{
previous = set_position(position - 1); //前一位就是指定位置的前一位
following = previous->next; //后一位就是指定位置
}
else following = head; //如果指定位置是表头,那么它的后一位就是当前表头
new_node = new Node<List_entry>(x, following); //创建新的数据域,并且将新的数据域与它的后一位连起来
if (new_node == NULL) return overflow; //判断创建是否成功
if (position == 0) head = new_node; //如果指定位置是表头,那么新的表头就是插入的数据
else
previous->next = new_node; //否则,将前一个与新创建的关联起来
count++; //计数器加一
return success;
}
template <class List_entry>
Error_code List<List_entry>::retrieve(int position, List_entry &x) const //读取指定位置的数据
{
Node<List_entry> *current;
if (position < 0 || position > count) return range_error; //判断指定位置是否合法
current = set_position(position); //将current指向指定位置
x = current->entry; //取出数据赋给x
return success;
}
template <class List_entry>
Error_code List<List_entry>::replace(int position, const List_entry &x) //替换指定位置的数据
{
Node<List_entry> *current;
if (position < 0 || position > count) return range_error; //判断指定位置是否合法
current = set_position(position); //将current指向指定位置
current->entry = x; //将要换入的值填入这个位置
return success;
}
template <class List_entry>
Error_code List<List_entry>::remove(int position, List_entry &x) //删除指定位置的数据
{
Node<List_entry> *prior,*current;
if(count == 0) return underflow;
if (position < 0 || position > count) return range_error; //判断指定位置是否合法
if(position > 0) //如果指定位置不是表头
{
prior = set_position(position - 1); //前一位就是指定位置的前一位
current = prior->next; //确定当前位置
prior->next = current->next; //将下一个元素和前一个相连
}
else{
current = head; //如果指定位置是表头,当前位置是表头
head = head->next; //表头变成下一个元素
}
delete current; //删除这个空间
count--; //计数器减一
return success;
}
template <class List_entry>
Node<List_entry> *List<List_entry>::set_position(int position) const //让指针指到指定位置
{
Node<List_entry> *q = head;
for (int i = 0; i < position; i++) q = q->next; //遍历,指到找到指定位置
return q;
}
template <class List_entry>
List<List_entry> ::~List() //析构函数
{
clear();
}
template <class List_entry>
List<List_entry> ::List(const List<List_entry> ©) //拷贝构造函数
{
count = copy.count; //表中元素个数相同
Node<List_entry> *new_node,*old_node = copy.head;
if(old_node == NULL) head = NULL; //如果原表为空则新表也为空
else{
new_node = head = new Node<List_entry>(old_node->entry); //定义新表的头
while(old_node->next != NULL) //遍历旧表
{
old_node = old_node->next;
new_node->next = new Node<List_entry>(old_node->entry);
new_node = new_node->next; //将旧表的每一项赋给新的表
}
}
}
template <class List_entry>
void List<List_entry> ::operator =(const List<List_entry> ©) //“=”运算符重载
{
List new_copy(copy); //调用拷贝构造函数
clear(); //将这个表清空
count = new_copy.count;
head = new_copy.head; //将拷贝的值传给新的表
new_copy.count = 0;
new_copy.head = NULL; //清空拷贝的表
}