[C++]数据结构实验03：链式结构线性表的基本操作

/**********************************************************************************************************************************/
/*	实验三：线性表操作
/*	1.创建线性表类。线性表的存储结构使用链表。
/*	2.完成表首插入元素、删除指定元素、搜索表中是否有指定元素、输出链表。
/*	3.输入n个不为零的整数作为节点元素值，遇到0代表输入结束（不创建元素值为0的节点），创建链表。输出整个链表。
/*	4.输入一个整数，将该数作为一个元素值插入表首位置。输出整个链表。
/*	5.输入一个整数，在链表中进行搜索，输出其在链表中的位置。如果不存在输出0。
/*	6.再一次输入一个整数，在链表中进行搜索，输出其在链表中的位置。如果不存在输出0。
/*	7.使用链表遍历器实现链表的反序输出。
/*	8.再一次输入n个不为零的整数作为节点元素值，遇到0代表输入结束（不创建元素值为0的节点），创建另外一个链表，输出整个链表。
/*	9.使用链表遍历器实现上面两个链表的合并，输出合并后的链表。
/**********************************************************************************************************************************/

#include <iostream>
#include<new.h>
using namespace std;

//节点类，定义了每个节点的存储类型和指针名称
template<class T>
class ChainNode{
public:
T data;
ChainNode<T> *link;
};

//链表类，封装了链表操作的相应方法
template<class T>
class Chain{
public:
Chain(){first=0;}                        //构造函数，头结点指向空值
~Chain();                                //析构函数
bool IsEmpty()const{return first==0;}    //判断是否为空
int Length()const;                        //返回该链表的长度
bool Find(int k,T&x)const;                //返回第k个元素到x中
int Search(const T&x)const;                //返回x所在的位置
Chain<T>& Delete(int k,T& x);            //删除第k个元素并把它返回到x中
Chain<T>& Insert(int k,const T&x);        //在第k个元素之后插入x
void Output(ostream& out) const;        //重载操作符的输出函数
ChainNode<T> *first;                    //指向第一个节点的指针
ChainNode<T> *last;                        //指向最后一个节点的指针

void Erase();
void Zero(){first=0;};
Chain<T>& Append(const T&x);

};

//链表遍历器类实现对链表的遍历
template<class T>
class ChainIterator{
public:
T* Initialize(const Chain<T>&c){
location = c.first;
if(location){
return &location->data;
}
return 0;
}

T* Next(){
if(!location)
return 0;
location = location->link;
if(location)
return &location->data;
return 0;
}
private:
ChainNode<T>*location;
};

//链表的析构函数，用于删除所有的链表中的节点
template<class T>
Chain<T>::~Chain(){
Erase();
}

//清除掉链表中的所有元素并且释放内存
template<class T>
void Chain<T>::Erase(){
ChainNode<T>*next;
//指向下一个节点
while(first){
next=first->link;
delete first;
first = next;
}
}

//输出链表
template<class T>
void Chain<T>::Output(ostream& out)const{
ChainNode<T>*current;
for(current=first;current;current=current->link){
out<<current->data;
if(!current->link){
out<<""<<endl;
}else{
out<<",";
}
}
}
//重载操作符
template<class T>
ostream& operator<<(ostream& out,const Chain<T>&x){
x.Output(out);
return out;
}

class OutOfBounds{
public:
OutOfBounds(){
cout<<"Out Of Bounds!"<<endl;
}
};

//内存不足的异常类
class NoMem{
public:
NoMem(){
cout<<"No Memory!"<<endl;
}
};
//使new引发NoMem异常而不是xalloc异常
//如果要恢复原始行为可以做以下调用
//_set_new_handler(Old_Handler);
int my_new_handler(size_t size){
throw NoMem();
}

//确认链表的长度
template<class T>
int Chain<T>::Length()const{
ChainNode<T>*current = first;
int length = 0;
while(current){
length++;
current = current->link;
}
return length;
}

//在链表中查找第k个元素
//存在就储存到x中
//不存在则返回false，否则返回true
template<class T>
bool Chain<T>::Find(int k,T&x)const{
if(k<1)
return false;
ChainNode<T>*current = first;
int index = 1;
while(index<k&& current){
current = current->link;
index++;
}
if(current){
x = current->data;
return true;
}
return false;
}

//在链表中搜索
//查找x，如果发现则返回x的下标
//如果x不存在则返回0
template<class T>
int Chain<T>::Search(const T&x)const{
ChainNode<T>*current = first;
int index = 1;
while(current&& current->data!=x){
current = current->link;
index++;
}
if(current){
return index;
}
return 0;
}

//从链表中删除一个元素
//将第k个元素取至x
//然后从链表中删除第k个元素
//如果不存在则引发异常OutOfBounds
template<class T>
Chain<T>& Chain<T>::Delete(int k,T& x){
if(k<1||!first){
throw OutOfBounds();
}
ChainNode<T>*p = first;
if(k==1){
first = first->link;
}else{
ChainNode<T>*q = first;
for(int index = 1;index<k-1&&q;index++){
q = q->link;
//此时q指向要删除的前一个节点
}
if(!q||!q->link){
throw OutOfBounds();
}
p = q->link;
if(p==last)
last=q;
q->link=p->link;
//从链表中删除该节点
x = p->data;
delete p;
return *this;
}
}

//在第k个位置之后插入元素
//不存在则报OutOfBounds异常
//没有足够内存则报NoMem异常
template<class T>
Chain<T>& Chain<T>::Insert(int k,const T&x){
if(k<0){
throw OutOfBounds();
}
ChainNode<T>*p = first;

for(int index = 1;index<k && p;index++){
p = p->link;
}
if(k>0 && !p){
throw OutOfBounds();
}
ChainNode<T>*y = new ChainNode<T>;
y->data = x;
if(k){
y->link=p->link;
p->link=y;
}else{
//作为第一个元素插入
y->link = first;
first = y;
}
if(!y->link)
last=y;
return *this;
}

//在链表右端添加一个数据
template<class T>
Chain<T>& Chain<T>::Append(const T&x){
ChainNode<T>*y;
y = new ChainNode<T>;
y->data = x;
y->link = 0;
if(first){
last->link = y;
last = y;
}else{
first = last = y;
}
return *this;
}

int main()
{
int count = 0;

//收集输入的内容至链表a当中
Chain<int> a;

cout<<"Input1"<<endl;
while(true)
{
int b;
cin>>b;
if(b==0)break;
a.Append(b);
count++;
}

cout<<"Output1"<<endl;
cout<<a<<endl;

cout<<"Input2"<<endl;
int c1;
cin>>c1;
a.Insert(0,c1);
count++;
cout<<"Output2"<<endl;
cout<<a<<endl;

cout<<"Input3"<<endl;
int q;
cin>>q;
cout<<"Output3"<<endl;
cout<<a.Search(q)<<endl;

cout<<"Input4"<<endl;
int q2;
cin>>q2;
cout<<"Output4"<<endl;
cout<<a.Search(q2)<<endl;

Chain<int> w;
count = 0;
cout<<"Input5"<<endl;

while(true){
int b;
cin>>b;
if(b==0)break;
w.Append(b);
count++;
}

//直接将w链表遍历加在a链表的尾部
cout<<"Output5"<<endl;
ChainNode<int>*current = w.first;
while (current)
{
a.Append(current->data);
current= current->link;
}
cout<<a<<endl;
return 0;
}