新手学习数据结构与算法---单链表（C++版， 跟C还是有点差别的）

//单链表的C++版本
//基本思想与C版本基本是完全一样的
#include <iostream>
#include <stdexcept>         //out_of_range索引错误

using namespace std;

template <typename T>               //前向声明
class Chain;

template <typename T>
class ChainNode
{
private:
friend class Chain<T>;               //一个友元类
T data;
ChainNode<T> *next;
};

template <typename T>
class Chain
{
private:
ChainNode<T> *first;     //指向第一个结点的指针
public:
Chain() {first = NULL;}
~Chain();
bool IsEmpty() const {return first == NULL;} //判表空
int Length() const;    //求表长
bool Find(int k, T & x) const;         //查找第K个元素.并返回它的值给x
int Search(const T & x) const;         //查找元素X，并返回它的位置
Chain<T> & Insert(int k, const T & x) throw(std::logic_error);            //将x插到第k个元素之后
Chain<T> & Delete(int k, T & x) throw(logic_error);      //删除第k个元素，并将它保存到x
void OutPut(ostream & out) const;         //将链表元素输出流
template <typename C>
friend ostream & operator << (ostream & out, Chain<C> & x);
};

template <typename T>
Chain<T>::~Chain()                     //析构函数
{
ChainNode<T> * p;
while(p)
{
p = first;
delete first;
first = p;
}
}

template <typename T>
int Chain<T>::Length() const      //求表长
{
ChainNode<T> * p;
int n = 0;
while(p)
{
n++;
p = p->next;
}
return n;
}

template <typename T>
bool Chain<T>::Find(int k, T & x) const             //查找第k个元素，并将其返回给x
{
if(k < 1) return false;
ChainNode<T> * p = first;
/*
int index = 0;
while(index < k - 1 && p)
*/
int index = 1;
while((index < k) && p)
{
p = p->next;
index++;
}
if(p)       //存在
{
x = p->data;
return true;
}
else
return false;
}

template <typename T>
int Chain<T>::Search(const T & x) const        //查找元素x，并返回它的下标
{
ChainNode<T> * p = first;
int index = 1;               //不是数组，所以是第几个
while(p && p->data != x)
{
p = p->next;
index++;
}
if(p) return index;             //若存在
return 0;
}

template <typename T>
Chain<T> & Chain<T>::Insert(int k, const T & x) throw(logic_error)         //在第k个元素之后插入元素x
{
//if(k < 1)             //因为插入可以插入第一位
if(k < 0) throw out_of_range();
ChainNode<T> * p = first;
for(int index = 1; index < k && p; index++)       //移到第k位
p = p->next;
if(k > 0 && !p) throw out_of_range();      //如果p为NULL
ChainNode<T> * q = new ChainNode<T>;
q->data = x;
if(k)
{
q->next = p->next;
p->next = q;
}
else           //若k为0，作为第一个元素插入
{
q->next = first;
first = q;
}
return *this;
}

template <typename T>
Chain<T> & Chain<T>::Delete(int k, T & x) throw(logic_error)    //删除第k个元素
{
if(k < 1 || !first)     //如果k<1或者first为NULL
throw out_of_range();
ChainNode<T> * p = first;
ChainNode<T> * q;
if(k == 1)        //如果已经指向第k个元素
first = first->next;         //删除
else
{
for(int index = 1; index < k - 1 && p; index++)      	//指向第k-1个元素
p = p->next;
if(!p || !p->next) throw out_of_range();  //如果p,p->next为null
q = p->next;
p->next = q->next;
}
x = q->data;           //把值赋给x
delete q;
return *this;
//中国的教材没有考虑的这么仔细
}

template <typename T>
void Chain<T>::OutPut(ostream & out) const      //输出链表
{
ChainNode<T> * p;
for(p = first; p; p = p->next)
out << p->data << " ";
}

template <typename C>
ostream & operator << (ostream & out, Chain<C> & x)
{
x.OutPut(out);
return out;
}

int main()
{
//自己测试
}