数据结构学习第一篇--C++实现单链表模板

刚刚开始学习数据结构，写了一个链表及其操作的模板，欢迎评论！

template <class T>
class Node
{
public:
T data;
Node<T> *Next;
};

template <class T>
class LIST
{
public:
LIST();
~LIST();
void InsertHead(T data);         //1.从头插入数据
void Display();                  //2.打印链表数据
bool Empty();                    //3.判断链表是否为空
Node<T> *Find(T data);           //4.查找指定数据,返回该节点的地址
void Delete(int m);              //5.指定位置删除节点
int Size();                      //6.返回链表的长度
void DeleteAll();                //7.删除整个连表的数据
void InsertEnd(T data);          //8.从尾插入数据
void Change(int xPos, T data);   //9.把单链表中第pos个结点的值修改为x的值
void InsertXpos(int xPos,T data);//10.向单链表中第pos个结点位置插入元素为x的结点
void InsertOrder(T data);        //11.向有序单链表中插入元素x结点，使得插入后仍然有序
void DeleteHead();               //12.从单链表中删除表头结点
void DeleteEnd();                //13.从单链表中删除表尾结点并返回它的值
void DeleteData(T data);         //14.从单链表中删除值为x的第一个结点
int FindxPos(T data);            //15.查找指定数据,返回首先遇到的节点是第几个节点, 没有则返回-1
void Exchange(T A, T B);         //16.交换两个节点的位置
void QSort();                    //17.快速排序
T FindinOrder(int order);        //18.按节点的位置查找，返回数据
void ChangeOrder();              //19.反转数据的顺序
private:
Node<T> *Head;

};

/*构造函数*/
template <class T>
LIST<T>::LIST()
{
Head = NULL;
}

template <class T>
LIST<T>::~LIST()
{
DeleteAll();
}

/*1.头插法*/
template <class T>
void LIST<T>::InsertHead(T data)
{
Node<T> *p1, *p2;
p1 = Head;
p2 = new Node<T>[1];
p2->data = data;
if (Head == NULL)  /*链表为空*/
{
Head = new Node<T>[1];
Head->data = data;
Head->Next = NULL;
}
else
{
p2->Next = p1;
Head = p2;
}
}

/*2.打印链表*/
template <class T>
void LIST<T>::Display()
{
for (Node<T> *p = Head; p != NULL; p = p->Next)
cout << p->data<<' ';
cout << endl;
}

/*3.判断链表是否为空*/
template <class T>
bool LIST<T>::Empty()
{
return Head == NULL ? true : false;
}


/*4.查找指定数据*/
template <class T>
Node<T> *LIST<T>::Find(T data)
{
Node<T> *p;
for (p = Head; p->data != data && p != NULL;)
p = p->Next;
return p;
}

/*5.指定位置删除节点*/
template <class T>
void LIST<T>::Delete(int m)
{
if (m <= 0) return;  //m小于等于0则返回
int i = 1;
Node<T> *q, *p = Head;
if (m == 1)  //删除头结点
{
Head = p->Next;
delete(p);
return;
}
for (; i < m - 1; i++)
p = p->Next;
q = p->Next;
p->Next = p->Next->Next;
delete(q);
q = NULL;
}

/*6.返回链表的长度*/
template <class T>
int LIST<T>::Size()
{
int i = 0;
for (Node<T> *p = Head; p != NULL; p = p->Next)
i++;
return i;
}

/*7.删除整个连表的数据*/
template <class T>
void LIST<T>::DeleteAll()
{
Node<T> *p, *q;
if (Head == NULL) return;       //链表为空直接返回
p = Head;
while (p != NULL)
{
Head = p->Next;
q = p;
p = p->Next;
delete(q);
q = NULL;
}
p = NULL;
}

/*8.从尾插入数据*/
template <class T>
void LIST<T>::InsertEnd(T data)
{
Node<T> *p, *q = new Node<T>[1];
q->data = data;
q->Next = NULL;
if (Head == NULL)
{
Head = q;
return;
}
for (p = Head; p->Next != NULL;)
p = p->Next;
p->Next = q;
}


/* 9.把单链表中第pos个结点的值修改为x的值 */
template <class T>
void LIST<T>::Change(int xPos, T data)
{
Node<T> *p = Head;
if (xPos < 1) return;
if (xPos == 1)
{
Head->data = data;
return;
}
for (int i = 1; i < xPos - 1 && p != NULL; i++)
{
if (p == NULL) return;
p = p->Next;
}
p->Next->data = data;
}


/*10.向单链表中第pos个结点位置插入元素为x的结点*/
template <class T>
void LIST<T>::InsertXpos(int xPos, T data)
{
if (xPos <= 0) return;
Node<T> *p = Head, *q = new Node<T>[1], *r;
q->data = data;
if (xPos == 1) //插入到头结点
{
q->Next = p;
Head = q;
return;
}
for (int i = 1; i < xPos-1; i++)
p = p->Next;
r = p->Next;
p->Next = q;
q->Next = r;
}


/*11.向有序单链表中插入元素x结点，使得插入后仍然有序*/
template <class T>
void LIST<T>::InsertOrder(T data)
{
if (Head == NULL || Head->Next == NULL) return;
Node<T> *q = new Node<T>[1];
q->data = data;
int i = Head->data < Head->Next->data ? 1 : 0; //升序i = 0，降序或者前两项相等i = 1
if (i == 1)  //升序
{
Node<T> *p = Head;
if (data <= p->data) //小于等于第一个数据则插到第一个节点上
InsertHead(data);
else
{
int xPos = 1;
for (; data > p->data && p->Next != NULL; p = p->Next)
xPos++;
InsertXpos(xPos, data);
}
}
if (i == 0)  //降序
{
Node<T> *p = Head;
if (data >= p->data)  //大于等于第一个数据则查到第一个节点上
InsertHead(data);
else
{
int xPos = 1;
for (; data < p->data && p->Next != NULL; p = p->Next)
xPos++;
InsertXpos(xPos, data);
}
}
}


/*12.从单链表中删除表头结点，并把该结点的值返回*/
template <class T>
void LIST<T>::DeleteHead()
{
Delete(1);
}




/*13.从单链表中删除表尾结点并返回它的值*/
template <class T>
void LIST<T>::DeleteEnd()
{
int x = Size();
Delete(x);
}


/*14.从单链表中删除值为x的第一个结点*/
template <class T>
void LIST<T>::DeleteData(T data)
{
Node<T> *p = Head;
int i = 1;
for (; p->data != data && p->Next != NULL; p = p->Next)
i++;
Delete(i);
}


/*15.查找指定数据,返回首先遇到的节点是第几个节点, 没有则返回-1*/
template <class T>
int LIST<T>::FindxPos(T data)
{
int xPos = 1;
Node<T> *p = Head;
for (; p != NULL && data != p->data; p = p->Next)
xPos++;
return p == NULL ? -1 : xPos;
}


/*16.交换两个节点的位置*/
template <class T>
void LIST<T>::Exchange(T A, T B)
{
if (A == B || FindxPos(A) == -1 || FindxPos(B) == -1) return; //元素相等或者某个元素不存在则返回


int a = FindxPos(A);
int b = FindxPos(B);
Delete(a);
InsertXpos(a, B);
Delete(b);
InsertXpos(b, A);
}


/*17.快速排序*/
template <class T>
void LIST<T>::QSort()
{ 
T tempkey = Head->data;
T key = tempkey;
int first = FindxPos(key);
int last = Size();
if (Head->Next->Next == NULL) return;  //如果只有两个元素则返回
 
for (; last > FindxPos(key) && FindinOrder(last) > key;) //从尾往头走
last--;
Exchange(key, FindinOrder(last));
for (; first < FindxPos(key) && FindinOrder(first) < key;) //从头往尾走
first++;
Exchange(key, FindinOrder(first));
if (first >= last) return;
tempkey = Head->data;
QSort();
tempkey = FindinOrder(last++);
QSort();
}


/*18.按节点的位置查找，返回数据*/
template <class T>
T LIST<T>::FindinOrder(int order)
{
Node<T> *p = Head;
for (int i = 1; i < order; i++)
p = p->Next;
return p->data;
}


/*19.反转数据的顺序*/
template <class T>
void LIST<T>::ChangeOrder()
{
int lenth = Size();
if (lenth < 2) return;  //数据少于两个则返回
int i = 1;
for (; i != lenth && i - lenth != 1; i++, lenth--)
Exchange(FindinOrder(i), FindinOrder(lenth));
}