C++单链表的建立（有头节点）

#ifndef chainWithHeader_
#define chainWithHeader_
#include<iostream>
#include<string>    //数组
#include<algorithm> //STL中的算法
#include<sstream>  //istringstream流
#include<exception>//异常处理
#include<vector>//迭代器
#include<numeric>//标准库中的数学操作函数
#include<iterator>
#include<array>
#include "chainNode.h"
using namespace std;
template<typename T>
class chainWithHeader
{
public:
chainWithHeader(int initialCapacity=10);
~chainWithHeader();

bool empty() const { return listSize == 0; }
int size() const { return listSize; }
void insert(int theIndex, const T& theElement);
void insertsort();
void output(ostream& out)const;
void bubblingSort();
void selectionSort();
void rankSort();
private:
chainNode<T>*headerNode;   //指向链表第一个节点的指针
int listSize;
};
template<typename T>
chainWithHeader<T>::chainWithHeader(int initialCapacity)
{
if (initialCapacity<1)
{
ostringstream s;
s << "Initial capacity= " << initialCapacity << "Must be>0";
throw illegalParameterValue(s.str());
}
headerNode = new chainNode<T>();
headerNode->next= NULL;
listSize = 0;
}
//析构函数，~chain(),思想，不断的删除首节点
template<typename T>
chainWithHeader<T>::~chainWithHeader()
{
while (headerNode->next!= NULL)
{
chainNode<T>* nextNode = headerNode->next;
delete headerNode;
headerNode = nextNode;
}
}
//插入函数
template<typename T>
void chainWithHeader<T>::insert(int theIndex, const T& theElement)
{
if (theIndex == 0)//把链表头赋给自己
headerNode->next = new chainNode<T>(theElement, headerNode->next);
else
{
chainNode<T>* p =headerNode->next;
for (int i = 0; i < theIndex - 1; i++)
p = p->next;
p->next = new chainNode<T>(theElement, p->next);
}
listSize++;
}
//输出函数
template<typename T>
void chainWithHeader<T>::output(ostream& out)const
{
for (chainNode<T>*p = headerNode; p->next != NULL; p = p->next)
out << p->next->element << " ";
}
//插入排序
template<typename T>
void chainWithHeader<T>::insertsort()
{
//将链表分成两段，一段有1个元素，另一段有n-1个元素，这是基础
chainNode<T>*p= headerNode->next->next;     //p代表第二个节点，此表从第二个节点开始
headerNode->next->next = NULL;              //只要一个元素的表，等待插入
chainNode<T>*r,*q;
while (p!= NULL)
{
r = p->next;                           //保存p后面还没比较的节点
q = headerNode;                        //新表的表头，每次从表头开始找
while (q->next != NULL&&q->next->element<= p->element)  //找到大于p的那个节点前驱
q = q->next;
p->next = q->next;                                 //p->next指向q->next的值
q->next = p;               //q->next指向p处的值，相当于从p指的链表找到一个元素放入headerNode所指链表的合适位置
p = r;                                             //进行下一次比较
}
}
//冒泡排序（有头结点）
template<typename T>
void chainWithHeader<T>::bubblingSort()
{
chainNode<T>*pr, *pt,*pb,*pf,*pd;//pd表示每次要比较的尾元素,pr表示比较元素的前一个，pt表示比较元素的后一个
pb = headerNode;            //pb为第一个比较元素的前驱
pr = headerNode->next;
pd = NULL;
pf = headerNode;            //pf就是为了得到每次排完序的头节点
bool swapped = true;        //为了在已经有序的情况下能及时退出
while (pf->next!=pd&&swapped)
{
pb = pf;                //pb为第一个比较元素的前驱
pr = pf->next;
swapped = false;        //目前为止未交换
while (pr->next!=pd)
{
pt = pr->next;
if (pr->element > pt->element)//如果两相邻的节点无序，则交换
{
pb->next = pt;
pr->next = pt->next;
pt->next = pr;
swapped = true;
}
pb = pb->next;
pr = pb->next;
}
pd = pr;//新的末尾
}
}
//选择排序（有头节点）
template<typename T>
void chainWithHeader<T>::selectionSort()
{
chainNode<T>*pd,*pf,*pe,*pa,*pmax;
pf = headerNode;
pd = NULL;
bool sorted = false;                         //已经排好序之后退出循环
while (pf->next->next!=pd&&!sorted)
{
pmax = pf;
pa= pf->next;
sorted = true;
T temp;
while (pa->next!= pd)
{
if (pmax->next->element<=pa->next->element)//找最大的元素
pmax= pa;
else sorted = false;
pe = pa;                           //记录每次查找完的最后一个元素的前驱
pa= pa->next;
}
/*pb = pe->next;
pbmax = pmax->next;

pmax->next = pb;
pbmax->next = pb->next;
pb->next = pbmax->next;
pe->next = pbmax;*/
temp = pmax->next->element;          //和最大值和尾值交换
pmax->next->element=pe->next->element;
pe->next->element = temp;

pd = pe->next;                             //记录尾节点，值最大
}
}
//计数排序
template<typename T>
void chainWithHeader<T>::rankSort()
{
//求排名
chainNode<T>*p, *pr;
p = headerNode->next->next;       //指向第二个元素
int*r= new int[listSize]();   //记录排名,默认初始化为0
int i = 1,j=0;
while (p != NULL)
{
pr = headerNode->next;
j = 0;
while (pr!= p)
{
if(pr->element <= p->element)
++r[i];
else ++r[j];
pr = pr->next;
++j;
}
p = p->next;
++i;
}
//根据名次排列
chainNode<T>*pb = headerNode->next;
int k = 0,t;
T temp;
while (pb != NULL)
{
int i =0;
chainNode<T>*pd = headerNode->next;
while (k!=r[i])
{
pd = pd->next;
++i;
}
if (k!=r[k])         //如果实际位置和名次相同，则不交换
{
//交换数据
temp = pb->element;
pb->element = pd->element;
pd->element = temp;
//交换名次
t = r[i];
r[i] = r[k];
r[k] = t;
}
pb = pb->next;
++k;
}
delete [] r;
}

#endif