线性表之单链表的c++实现

单链表是线性表的一种链式存储结构,它同顺序表(由于顺序表实现比较简单,本文不做讲述了)不同,是用一组任意地址的存储单元,存放线性表中的元素。为了表示结点之间的关系,每个结点不仅要存储它表示的元素，还要存储它下一个结点的信息。

下面我们用C++的模版来实现以下单链表:

结点定义

template <class T>
struct Node
{
Node* pNextNode;
T m_value;
};

单链表定义:

template <class T>
class CLinkList
{
private:
Node<T>* m_pHead;
int m_nLength; // 单链表长度
// 一元多项式求和
friend void Add(CLinkList<elem> & A, CLinkList<elem>& B);</span>
public:
friend void Circle(int n, int m);

// 约瑟夫环
CLinkList();</span>
// 初始化含有n个元素,值为value的单链表n>=1
CLinkList(int n, T value);
~CLinkList();
// 求单链表长度
int GetLength();
// 删除单链表的第i个结点,返回删除结点的值
T Delete(int i);
// 在单链表中第i个位置插入值为x的元素
void Insert(int i, T x);
// 返回值为value的序号
int GetValue(T value);
// 返回第i个元素的值
T GetLocate(int i);
// 单链表遍历
void PrintList();
// 单链表逆序
void Reverse();
将当链表转换成环,此方法使用之后,只能使用Delete(i)方法;此方法是为了解决约瑟夫环问题
void Ring();
};

template <class T>
CLinkList<T>::CLinkList()
{
m_pHead = NULL;
}

1)关于单链表的创建

单链表的创建有两种方法:头插法:新插入的元素始终为插入的第一个元素创建过程:初始化头指针为NULL,每创建一个元素,使其指向头指针,将头指针指向这个新创建的元素.

尾插法:先创建单链表头指针元素,创建一个尾指针,指向当前元素.每创建一个元素,将尾指针元素的下一个结点指向创建元素,尾指针指向当前元素.

template <class T>
CLinkList<T>::CLinkList(int n, T value)
{
if (n < 1)
{
m_pHead = NULL;
return;
}
// 头插法建立单链表
/*for (int i = 0; i<n; i++)
{
Node* pNode = new Node<T>;
pNode->m_value = value;
pNode->pNextNode = pHead;
pHead = pNode;
}*/
// 尾插法建立单链表
m_pHead = new Node<T>;
m_pHead->m_value = value++;
m_pHead->pNextNode = NULL;
Node<T>* pTail = m_pHead;
for (int i = 1; i<n; i++)
{
Node<T>* pWork = new Node<T>;
pWork->m_value = value++;
pWork->pNextNode = NULL;
pTail->pNextNode = pWork;
pTail = pWork;
}
}

2)求单链表长度

从头结点遍历到尾结点,获取长度.
<pre name="code" class="cpp">template <class T>
int CLinkList<T>::GetLength()
{
if (m_pHead == NULL)
{
return 0;
}
int i = 0;
Node<T>* r = m_pHead;
while (r != NULL)
{
i++;
r = r->pNextNode;
}
return i;
}

3)删除指定位置的链表结点,返回删除结点的值

要特别注意删除位置是头结点的情况,需要将头指针重新指向

另外为了删除结点,还要保存当前删除结点的前驱结点信息.
<pre name="code" class="cpp">template <class T>
T CLinkList<T>::Delete(int i)
{
if (i <= 0 || m_pHead == NULL)
{
CError error("删除位置异常");
throw error;
}
// 头指针删除
if (i == 1)
{
Node<T>* r = m_pHead;
m_pHead = m_pHead->pNextNode;
int nValue = r->m_value;
delete r;
return nValue;
}
Node<T>* r = m_pHead;
Node<T>* prev = m_pHead;
while (--i && r != NULL)
{
prev = r;
r = r->pNextNode;
}
if (r == NULL)
{
CError error("链表未初始化");
throw error;
}
// r是要删除的结点,prev是前置结点
int value = r->m_value;
prev->pNextNode = r->pNextNode;
delete r;
return value;
}

4)在位置i插入值为x的结点

<pre name="code" class="cpp">template <class T>
void CLinkList<T>::Insert(int i, T x)
{
if (i <= 0)
{
CError error("插入位置异常!");
throw  error;
}
if (m_pHead == NULL)
{
m_pHead = new Node<T>;
m_pHead->m_value = x;
m_pHead->pNextNode = NULL;
return;
}
// 寻找插入结点
Node<T>* r = m_pHead;
Node<T>* prev = m_pHead;
while (--i && r!=NULL)
{
prev = r;
r=r->pNextNode;
}
if (r == NULL) // 此种情况认为插在队尾
{
r = new Node<T>;
r->m_value = x;
r->pNextNode = NULL;
prev->pNextNode = r;
return;
}
// 如果是在头结点插入,将头指针指向这个结点,这个结点下一个为原来的头指针
if (r == m_pHead)
{
Node<T>* pNode = new Node<T>;
pNode->m_value = x;
pNode->pNextNode = r;
m_pHead = pNode;
return;
}

Node<T>* pNode = new Node<T>;
pNode->m_value = x;
pNode->pNextNode = r;
prev->pNextNode = pNode;
return;
}

5)获取指定位置的元素值

template <class T>
T CLinkList<T>::GetLocate(int i)
{
Node<T>* pNode = m_pHead;
while (--i && pNode != NULL)
{
pNode = pNode->pNextNode;
}
if (pNode == NULL)
{
CError error("查找位置非法");
throw error;
}
int nValue = pNode->m_value;
return nValue;
}

6)获取值为value元素的位置

template <class T>
int CLinkList<T>::GetValue(T value)
{
int j = 1;
Node<T>* pNode = m_pHead;
while ( pNode != NULL )
{
if (pNode->m_value == value)
{
return j;
}
j++;
pNode = pNode->pNextNode;
}
// 没有找到
return -1;
}

7)单链表遍历输出

template <class T>
void CLinkList<T>::PrintList()
{
Node<T>* pNode = m_pHead;
while (pNode != NULL)
{
printf("%d\r\n", pNode->m_value);
pNode = pNode->pNextNode;
}
}

8)单链表析构释放内存template <class T>

CLinkList<T>::~CLinkList()

{
Node<T>* pNode = m_pHead;
while (pNode != NULL)
{
Node<T>* r = pNode;
pNode = pNode->pNextNode;
delete r;
}
m_pHead = NULL;

}9)单链表逆序

template <class T>
void CLinkList<T>::Reverse()
{
Node<T>* pPrev = NULL;
Node<T>* pCur = m_pHead;
while(pCur!=NULL && pCur->pNextNode != NULL)
{
Node<T>* next = pCur->pNextNode;
pCur->pNextNode = pPrev;
pPrev = pCur;
pCur = next;
}
pCur->pNextNode = pPrev;
m_pHead = pCur;
}

10)使单链表形成环,为了解决一些环形链表的问题。但是将链表转换为环后,关于单链表尾指针后继结点为NULL的判断将不成立,

所以一些插入,删除等方法将不能是用，必须注意!!!

<pre name="code" class="cpp">template <class T>
void CLinkList<T>::Ring()
{
if (m_pHead == NULL)
{
return;
}
// 找到尾结点
Node<T>* r = m_pHead;
while (r->pNextNode != NULL)
{
r = r->pNextNode;
}
// 找到了尾结点,使其指向头结点
r->pNextNode = m_pHead;
}

11)友元函数实现一元多项式求和

一个单链表的实际应用,一元多项式求和.(这个有点问题,以后有机会再修改,大致思路是这样的)
<pre name="code" class="cpp">void Add(CLinkList<elem> & A, CLinkList<elem>& B)
{
Node<elem>* pa = A.m_pHead;
Node<elem>* pb = B.m_pHead;
Node<elem>* pPrevA = NULL;
Node<elem>* pPrevB = NULL;
while (pa != NULL && pb != NULL)
{
// 如果A系数大于B, 将B元素插入到A当前元素的前边
if (pa->m_value.exp > pb->m_value.exp)
{
Node<elem>* r = new Node<elem>;
r->m_value.coef = pb->m_value.coef;
r->m_value.exp = pb->m_value.exp;
if (pa == A.m_pHead) // 头结点之前插入,要改变头指针
{
r->pNextNode = pa;
A.m_pHead = r;
pPrevA = r;
pPrevB = pb;
pb = pb->pNextNode;
}else // 如果不是头指针
{
r->pNextNode = pa;
pPrevA->pNextNode = r;
pPrevA = r;
pPrevB = pb;
pb = pb->pNextNode;
}
// 将b元素删除
if (pb == B.m_pHead )
{
Node<elem>* s = pb;
pb = pb->pNextNode;
B.m_pHead = pb;
pPrevB = NULL;
delete s;
}else
{
Node<elem>* s = pb;
pb = pb->pNextNode;
pPrevB->pNextNode = pb;
delete s;
}

}else if (pa->m_value.exp < pb->m_value.exp) // 如果A系数小于B,比较A下一个元素
{
pPrevA = pa;
pa = pa->pNextNode;
}else // 如果相等,求和
{
pa->m_value.coef += pb->m_value.coef;
if (pa->m_value.coef == 0) // 如果系数为0,删除pa当前元素
{
if (pa == A.m_pHead)
{
A.m_pHead = pa->pNextNode;
Node<elem>* s = pa;
pa = pa->pNextNode;
pPrevB = pb;
pb = pb->pNextNode;
delete s;
}else
{
pPrevA->pNextNode = pa->pNextNode;
pPrevA = pa;
Node<elem>* s = pa;
pa = pa->pNextNode;
pPrevB = pb;
pb = pb->pNextNode;
delete s;
}
}else
{
pPrevA = pa;
pPrevB = pb;
pa = pa->pNextNode;
pb = pb->pNextNode;
}
}
}
if (pb != NULL)
{
pPrevA->pNextNode = pb;
}
}

12)约瑟夫环问题

void Circle(int n, int m)
{
CLinkList<int> MyLinkList;
for (int i = 1; i<=n; i++)
{
MyLinkList.Insert(i, i);
}
printf("报数:");
MyLinkList.PrintList();
// 环
MyLinkList.Ring();
printf("报%d出圈,出圈次序:", m);
int k = m;
Node<int>* pWork = MyLinkList.m_pHead;
Node<int>* pPrev = pWork;
for (int i = 0; i<n; i++)
{
while (--k)
{
pPrev = pWork;
pWork = pWork->pNextNode;
}
k = m;
printf("出圈%d, ", pWork->m_value);
Node<int>* s = pWork;
pPrev->pNextNode = pWork->pNextNode;
pWork = pWork->pNextNode;
delete s;
}
MyLinkList.m_pHead = NULL;
}

注:红色功能是复杂的功能,不是单链表的必有实现.

单链表是链式存储结构,为了查找第i个元素,必须先找到i-1个元素.不同于顺序表的随机存取结构.

下面是百度转载的一份关于顺序表和单链表的比较:

在C++ STL中vector和list的实现,类似于顺序表和单链表,两种结构什么情况使用也可以参照下面的比较.

顺序表与链表的比较
一、顺序表的特点是逻辑上相邻的数据元素，物理存储位置也相邻，并且，顺序表的存储空间需要预先分配。
它的优点是：
　　（1）方法简单，各种高级语言中都有数组，容易实现。
　　（2）不用为表示节点间的逻辑关系而增加额外的存储开销。
　　（3）顺序表具有按元素序号随机访问的特点。
缺点：
　　（1）在顺序表中做插入、删除操作时，平均移动表中的一半元素，因此对n较大的顺序表效率低。
　　（2）需要预先分配足够大的存储空间，估计过大，可能会导致顺序表后部大量闲置；预先分配过小，又会造成溢出。
二、在链表中逻辑上相邻的数据元素，物理存储位置不一定相邻，它使用指针实现元素之间的逻辑关系。并且，链表的存储空间是动态分配的。
链表的最大特点是：
　　插入、删除运算方便。
缺点：
　　（1）要占用额外的存储空间存储元素之间的关系，存储密度降低。存储密度是指一个节点中数据元素所占的存储单元和整个节点所占的存储单元之比。
　　（2）链表不是一种随机存储结构，不能随机存取元素。
三、顺序表与链表的优缺点切好相反，那么在实践应用中怎样选取存储结构呢？通常有以下几点考虑：
　　（1）顺序表的存储空间是静态分配的，在程序执行之前必须明确规定它的存储规模，也就是说事先对“MaxSize”要有合适的设定，设定过大会造成存储空间的浪费，过小造成溢出。因此，当对线性表的长度或存储规模难以估计时，不宜采用顺序表。然而，链表的动态分配则可以克服这个缺点。链表不需要预留存储空间，也不需要知道表长如何变化，只要内存空间尚有空闲，就可以再程序运行时随时地动态分配空间，不需要时还可以动态回收。因此，当线性表的长度变化较大或者难以估计其存储规模时，宜采用动态链表作为存储结构。
　　但在链表中，除数据域外海需要在每个节点上附加指针。如果节点的数据占据的空间小，则链表的结构性开销就占去了整个存储空间的大部分。当顺序表被填满时，则没有结构开销。在这种情况下，顺序表的空间效率更高。由于设置指针域额外地开销了一定的存储空间，从存储密度的角度来讲，链表的存储密度小于1.因此，当线性表的长度变化不大而且事先容易确定其大小时，为节省存储空间，则采用顺序表作为存储结构比较适宜。
　　（2）基于运算的考虑（时间）
　　顺序存储是一种随机存取的结构，而链表则是一种顺序存取结构，因此它们对各种操作有完全不同的算法和时间复杂度。例如，要查找线性表中的第i个元素，对于顺序表可以直接计算出a(i)的的地址，不用去查找，其时间复杂度为0(1).而链表必须从链表头开始，依次向后查找，平均需要0(n)的时间。所以，如果经常做的运算是按序号访问数据元素，显然顺表优于链表。
　　反之，在顺序表中做插入，删除时平均移动表中一半的元素，当数据元素的信息量较大而且表比较长时，这一点是不应忽视的；在链表中作插入、删除，虽然要找插入位置，但操作是比较操作，从这个角度考虑显然后者优于前者。
　　（3）基于环境的考虑（语言）
　　顺序表容易实现，任何高级语言中都有数组类型；链表的操作是基于指针的。相对来讲前者简单些，也用户考虑的一个因素。
　　总之，两种存储结构各有长短，选择哪一种由实际问题中的主要因素决定。通常“较稳定”的线性表，即主要操作是查找操作的线性表，适于选择顺序存储；而频繁做插入删除运算的（即动态性比较强）的线性表适宜选择链式存储。