数据结构—单链表(模板类)

  链表概念--链表是一种线性表，但是并不是顺序存储，而是每个节点里面存储着下一个节点的指针，把存储数据元素的数据串链起来

单链表的实现

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

template <class T>
struct Node
{
 Node(const T& x)
 :_data(x)
 , _pNext(NULL)
 { }

 Node<T> *_pNext;
 T _data;
};
template <class T>
class SList
{
public:
 SList()
 :_pHead(NULL)
 , _size(0)
 { }

 SList(const SList<T>& l)
 {
 Node<T>*pNode = l._pHead;

 while (pNode)
 {
 PushBack(pNode->_data);
 pNode = pNode->_pNext;
 }
 }

 ~SList()
 {
 Clear();
 }

 void Clear()
 {
 Node<T>*pNode = _pHead;

 while (pNode)
 {
 Node<T>* pDel = pNode;
 pNode = pNode->_pNext;
 delete pDel;
 }
 _pHead = NULL;
 _size = 0;
 }

 SList& operator = (const SList& other)
 {
 if (this != &other)
 {

 Node<T> *pNode = other._pHead;
 while (NULL != pNode)
 {
 PushBack(pNode->_data);
 pNode = pNode->_pNext;
 }
 }

 return *this;
 }

 //尾插
 void PushBack(const T& x)
 {
 Node<T>*pNode = _BuyNode(x);
 Node<T>*cur = _pHead;
 if (Empty())
 {
 _pHead = pNode;
 }
 else
 {
 while (cur->_pNext)
 {
 cur = cur->_pNext;
 }
 cur->_pNext = pNode;
 }
 _size++;
 }
 //尾删
 void PopBack()
 {
 if (Empty())
 {
 return;
 }
 else if (_size == 1)
 {
 delete _pHead;
 _pHead = NULL;
 _size = 0;
 }
 else
 {
 Node<T>*pNode = _pHead;
 Node<T>*pPreNode = NULL;
 while (pNode->_pNext)
 {
 pPreNode = pNode;
 pNode = pNode->_pNext;
 }
 pPreNode->_pNext = NULL;
 delete pNode;
 _size--;
 }

 }
 //头插
 void PushFront(const T&x)
 {
 Node<T>*pNode = _BuyNode(x);
 if (Empty())
 {
 _pHead = pNode;
 }
 else
 {
 pNode->_pNext = _pHead;
 _pHead = pNode;
 }
 _size++;
 }
 //头删
 void PopFront()
 {
 if (Empty())
 {
 return;
 }
 else if (_size == 1)
 {
 delete _pHead;
 _pHead = NULL;
 _size = 0;
 }
 else
 {
 Node<T>*pNewNode = _pHead;
 _pHead = _pHead->_pNext;
 delete pNewNode;
 pNewNode = NULL;
 _size--;
 }
 }
 //显示
 void Print()
 {
 Node<T>*cur = _pHead;
 while (cur)
 {
 cout << cur->_data << "->";
cur = cur->_pNext;
 }
 cout << "NULL";
 }
 //查找
 Node<T>* Serach(const T&x)
 {
 if (Empty())
 {
 return 0;
 }
 Node<T>*cur = _pHead;
 while (cur)
 {
 if (cur->_data == x)
 {
 return cur;
 }
 cur = cur->_pNext;
 }
 return NULL;
 }
 //删除
 void Erase(Node<T>*pos)
 {

 if (Empty())
 {
 return;
 }
 if (pos == _pHead)
 {
 _pHead = pos->_pNext;
 delete pos;
 }
 else
 {
 Node<T>*cur = _pHead;
 while (cur)
 {
 if (cur->_pNext == pos)
 {
 cur->_pNext = pos->_pNext;
 delete pos;
 }
 cur = cur->_pNext;
 }
 }
 }

 //排序（冒泡法）
 void BubbleSort()
 {
 Node<T>* ptail = NULL;
 Node<T>*pNode = NULL;
 Node<T>* ppreNode = NULL;

 if (_pHead == NULL || _pHead->_pNext == NULL)
 {
 return;
 }
 while (_pHead != ptail)
 {
 int exchange = 0;
 ppreNode = _pHead;
 pNode = _pHead->_pNext;
 while (pNode != ptail)
 {
 if (ppreNode->_data > pNode->_data)
 {
 T temp;
 temp = ppreNode->_data;
 ppreNode->_data = pNode->_data;
 pNode->_data = temp;
 exchange = 1;
 }
 ppreNode = pNode;
 pNode = pNode->_pNext;
 }
 if (exchange == 0)
 {
 return;
 }
 ptail = ppreNode;
 }
 }

 //逆置（前插）
 void Reverse()
 {
 Node<T>* pPreNode = NULL;
 Node<T>* pNewNode = NULL;
 Node<T>* pNode = _pHead;
 if (_pHead == NULL || (_pHead)->_pNext == NULL)
 {
 return;
 }
 while (pNode)
 {
 pPreNode = pNode;
 pNode = pNode->_pNext;
 pPreNode->_pNext = pNewNode;
 pNewNode = pPreNode;
 }
 _pHead = pNewNode;
 }

 bool Empty()
 {
 return _size == 0;
 }

 T & operator[](size_t index)
 {
 if (index >= _size)
 {
 cout << "index error" << endl;
 abort();
 }
 Node<T>* pNode = _pHead;
 while (index--)
 {
pNode = pNode->_pNext;
 }
 return pNode->_data;
 }

 const T & operator[](size_t index) const
 {
 if (index >= _size)
 {
 cout << "index error" << endl;
 abort();
 }
 Node* pNode = _pHead;
 while (index--)
 {
pNode = pNode->_pNext;
 }
 return pNode->_data;
 }

 friend ostream& operator << (ostream& _cout, const SList<T>&l)
 {
 Node<T> *pNode = l._pHead;

 while (pNode)
 {
 _cout << pNode->_data << "->";
pNode = pNode->_pNext;
 }
 _cout << "NULL";
 return _cout;
 }

 Node<T>*FindMidNode();

private:
 Node<T>* _BuyNode(const T& data)
 {
 return new Node<T>(data);
 }

private:
 Node<T> *_pHead;
 size_t _size;
};
//查找单链表的中间节点
template <typename T>
Node<T>*SList<T>::FindMidNode()
{
 Node<T>*pFast = _pHead;
 Node<T>*pSlow = _pHead;
 while (pFast&&pFast->_pNext)
 {
 pFast = pFast->_pNext->_pNext;
 pSlow = pSlow->_pNext;
 }
 return pSlow;
}

void main()
{
 SList<int> s;

 s.PushBack(6);
 s.PushBack(3);
 s.PushBack(7);
 cout << s[0] << endl;
 cout << s << endl;

 SList<int> s1(s);

 cout << s1 << endl;

 s.Print();

}