"《算法导论》之‘线性表’"：基于指针实现的单链表

　　对于单链表的介绍部分参考自博文数组、单链表和双链表介绍 以及 双向链表的C/C++/Java实现。

　 1. 单链表介绍

　　单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针。

　  1.1 单链表的示意图

　　

　　表头为空，表头的后继节点是"节点10"(数据为10的节点)，"节点10"的后继节点是"节点20"(数据为10的节点)，...

　  1.2 单链表添加节点

　　

　　在"节点10"与"节点20"之间添加"节点15"
　　添加之前："节点10" 的后继节点为"节点20"。
　　添加之后："节点10" 的后继节点为"节点15"，而"节点15" 的后继节点为"节点20"。

　　需要注意的是在链表头部和其他地方添加结点是不一样的。

　　在链表头部添加结点的关键代码为：

 NodePointer ptr = new Node();
 ptr->data = val;
 ptr->next = head;
 head = ptr;

　　在其他地方添加结点的关键代码为：

 NodePointer ptr = new Node(), tmpPtr = head;
 ptr->data = val;
 while(...){...}
 ptr->next = tmpPtr->next;
 tmpPtr->next = ptr;

　  1.3 单链表删除节点

　　

　　删除"节点30"
　　删除之前："节点20" 的后继节点为"节点30"，而"节点30" 的后继节点为"节点40"。
　　删除之后："节点20" 的后继节点为"节点40"。

　　需要注意的是在链表首部、尾部和其他地方删除结点是不一样的。

　　在链表首部删除结点的关键代码为：

 NodePointer ptr = head, tmpPtr;
 ...if (pos == )                // 在链表第一个位置
 {
     head = ptr->next;
     delete ptr;
 }

　　在链表尾部删除结点的关键代码为：

 NodePointer ptr = head, tmpPtr;
 while (...){...}
 tmpPtr = ptr->next;
 ptr->next = NULL;
 delete tmpPtr;

　　在其他地方删除结点的关键代码为：

 NodePointer ptr = head, tmpPtr;
 while(...){...}
 tmpPtr = ptr->next;
 ptr->next = tmpPtr->next;
 delete tmpPtr;

　 2. 代码实现

　　对于单链表，我定义了一个这样的类LinkedList：

 // linkedlist.h
 #ifndef LINKEDLIST
 #define LINKEDLIST

 #include <iostream>
 #include <cassert>

 using namespace std;

 typedef int ElementType;

 class Node
 {
 public:
     ElementType data;
     Node * next;
 };
 typedef Node * NodePointer;

 class LinkedList
 {
 public:
     LinkedList();
     virtual ~LinkedList();
     LinkedList(const LinkedList& origlist);　　　　　　　　 // 拷贝构造函数
     LinkedList& operator=(const LinkedList& origlist);　　// 赋值运算符重载
     void initList(ElementType * arr, int len);
     bool isEmpty();
     bool addNode(const int pos, const ElementType val);
     bool deleteNode(const int pos);
     void displayNodes();
     NodePointer getNode(const int pos);
     int getLenOfList();

 private:
     NodePointer head;

 };

 #endif // LINKEDLIST

　　实现代码如下：

 // linkedlist.cpp
 #include "linkedlist.h"

 LinkedList::LinkedList()
 {
     head = NULL;
 }

 LinkedList::~LinkedList()
 {
     NodePointer ptr = head, tmpPtr;
     while (ptr != NULL)
     {
         tmpPtr = ptr;
         ptr = ptr->next;
         delete tmpPtr;
     }
 }

 LinkedList::LinkedList(const LinkedList& origlist)
 {
     //head = origlist.head;        // 很容易写成这样，这样会造成浅拷贝
     NodePointer ptr = origlist.head;
     int i = ;
     while (ptr != NULL)
     {
         addNode(i, ptr->data);
         ptr = ptr->next;
         i++;
     }
 }

 LinkedList& LinkedList::operator=(const LinkedList& origlist)
 {
     //head = origlist.head;        // 很容易写成这样，这样会造成浅拷贝
     NodePointer ptr = origlist.head;
     int i = ;
     while (ptr != NULL)
     {
         addNode(i, ptr->data);
         ptr = ptr->next;
         i++;
     }
     return *this;
 }

 void LinkedList::initList(ElementType * arr, int len)
 {
     for (int i = ; i < len; i++)
     {
         addNode(i, arr[i]);
     }
 }

 bool LinkedList::isEmpty()
 {
     return head == NULL;
 }

 bool LinkedList::addNode(const int pos, const ElementType val)
 {
     bool success = true;
     int len = getLenOfList();
     // assert(0 <= pos <= len);
     if (pos <  || pos > len)
     {
         cerr << "The node at position " << pos << " you want to add is less than zero or larger than "
              << "the length of list ." << endl;
         success = false;
         throw out_of_range("out_of_range");
     }
     else
     {
         NodePointer ptr = new Node();
         ptr->data = val;
         if (pos == )                // 如果添加的元素在第1个
         {
             ptr->next = head;
             head = ptr;
         }
         else                        // 其他
         {
             NodePointer tmpPtr = head;
             int count = ;
             while (tmpPtr != NULL && count < pos - )
             {
                 tmpPtr = tmpPtr->next;
                 count++;
             }
             ptr->next = tmpPtr->next;
             tmpPtr->next = ptr;
         }

     }

     return success;
 }

 bool LinkedList::deleteNode(const int pos)
 {
     bool success = true;
     int len = getLenOfList();
     if (len == )
     {
         cerr << "There is no element in the list." << endl;
         success = false;
     }
     else
     {
         NodePointer ptr = head, tmpPtr;
         int count = ;
         // assert(0 <= pos <= len);
         if (pos <  || pos > len - )
         {
             cerr << "The node at position " << pos << " you want to delete is less than zero or larger than "
                 << "the length of list ." << endl;
             success = false;
             throw out_of_range("out_of_range");
         }
         else if (pos == )                // 在链表第一个位置
         {
             head = ptr->next;
             delete ptr;
         }
         else if (pos == len - )        // 在链表最后一个位置
         {
             while (ptr != NULL && count < pos - )
             {
                 ptr = ptr->next;
                 count++;
             }
             tmpPtr = ptr->next;
             ptr->next = NULL;
             delete tmpPtr;
         }
         else                            // 其他
         {
             while (ptr != NULL && count < pos - )
             {
                 ptr = ptr->next;
                 count++;
             }
             tmpPtr = ptr->next;
             ptr->next = tmpPtr->next;
             delete tmpPtr;
         }
     }
     return success;
 }

 void LinkedList::displayNodes()
 {
     int len = getLenOfList();
     if (len == )
     {
         cerr << "There is no element in the list." << endl;
     }
     else
     {
         NodePointer ptr = head;
         int sequence = ;
         while (ptr != NULL)
         {
             cout << "Seq: " << sequence << "; Data: " << ptr->data << "."<< endl;;
             ptr = ptr->next;
             sequence++;
         }
     }

 }

 NodePointer LinkedList::getNode(const int pos)
 {
     int len = getLenOfList();
     if (len == )
     {
         cerr << "There is no element in the list." << endl;
         return NULL;
     }
     else
     {
         // assert(0 <= pos <= len);
         if (pos <  || pos > len - )
         {
             cerr << "The item at position " << pos << " you want to get is less than zero or "
                 << "larger than the length of list." << endl;
             throw out_of_range("out_of_range");
             // return NULL;
         }
         else
         {
             NodePointer ptr = head;
             int count = ;
             while (ptr != NULL && count < pos)
             {
                 ptr = ptr->next;
                 count++;
             }
             return ptr;
         }
     }
 }

 int LinkedList::getLenOfList()
 {
     int len = ;
     NodePointer ptr = head;
     while (ptr != NULL)
     {
         len++;
         ptr = ptr->next;
     }
     return len;
 }

linkedlist.cpp

　　Boost单元测试代码如下：

 // BoostUnitTest.cpp
 #define BOOST_TEST_MODULE LinkedList_Test_Module

 #include "stdafx.h"
 #include "D:\VSProject\Algorithm\List\LinkedList\SingleLinkedList_BasedOnPointer\SingleLinkedList\SingleLinkedList\linkedlist.h"

 struct LinkedList_Fixture
 {
 public:
     LinkedList_Fixture()
     {
         testLinkedList = new LinkedList();
     }
     ~LinkedList_Fixture()
     {
         delete testLinkedList;
     }

     LinkedList * testLinkedList;

 };

 BOOST_FIXTURE_TEST_SUITE(LinkedList_Test_Suite, LinkedList_Fixture)

 BOOST_AUTO_TEST_CASE( LinkedList_Normal_Test )
 {
     // isEmpty --------------------------------------------
     BOOST_REQUIRE(testLinkedList->isEmpty() == true);

     // getLenOfList ---------------------------------------
     BOOST_REQUIRE(testLinkedList->getLenOfList() == );

     // addNode & getNode  ---------------------------------
     BOOST_REQUIRE(testLinkedList->addNode(, ) == true);
     BOOST_REQUIRE((testLinkedList->getNode())->data == );
     BOOST_REQUIRE((testLinkedList->getNode())->next == NULL);
     BOOST_REQUIRE(testLinkedList->isEmpty() == false);
     BOOST_REQUIRE(testLinkedList->getLenOfList() == );

     BOOST_REQUIRE(testLinkedList->addNode(, ) == true);
     BOOST_REQUIRE((testLinkedList->getNode())->data == );
     BOOST_REQUIRE((testLinkedList->getNode())->next == NULL);
     BOOST_REQUIRE(testLinkedList->isEmpty() == false);
     BOOST_REQUIRE(testLinkedList->getLenOfList() == );

     BOOST_REQUIRE(testLinkedList->addNode(, ) == true);
     BOOST_REQUIRE((testLinkedList->getNode())->data == );
     BOOST_REQUIRE((testLinkedList->getNode())->next != NULL);
     BOOST_REQUIRE(testLinkedList->isEmpty() == false);
     BOOST_REQUIRE(testLinkedList->getLenOfList() == );

     // deleteNode -----------------------------------------
     BOOST_REQUIRE(testLinkedList->deleteNode() == true);
     BOOST_REQUIRE((testLinkedList->getNode())->data == );
     BOOST_REQUIRE(testLinkedList->getLenOfList() == );

     BOOST_REQUIRE(testLinkedList->deleteNode() == true);
     BOOST_REQUIRE((testLinkedList->getNode())->data == );
     BOOST_REQUIRE(testLinkedList->getLenOfList() == );

     BOOST_REQUIRE(testLinkedList->deleteNode() == true);
     BOOST_REQUIRE(testLinkedList->getLenOfList() == );

     // initList -------------------------------------------
     int arr[] = { , ,  };
     int len = sizeof(arr) / sizeof(int);
     testLinkedList->initList(arr, len);
     BOOST_REQUIRE(testLinkedList->getLenOfList() == );
     BOOST_REQUIRE((testLinkedList->getNode())->data == );
     BOOST_REQUIRE((testLinkedList->getNode())->data == );
     BOOST_REQUIRE((testLinkedList->getNode())->data == );
     BOOST_REQUIRE((testLinkedList->getNode())->next == NULL);

 }

 BOOST_AUTO_TEST_CASE(LinkedList_Abnormal_Test)
 {
     int arr[] = { , ,  };
     int len = sizeof(arr) / sizeof(int);
     testLinkedList->initList(arr, len);

     // addNode -------------------------------------------
     BOOST_REQUIRE_THROW(testLinkedList->addNode(-, ), out_of_range);
     BOOST_REQUIRE_THROW(testLinkedList->addNode(, ), out_of_range);

     // deleteNode ----------------------------------------
     BOOST_REQUIRE_THROW(testLinkedList->deleteNode(-), out_of_range);
     BOOST_REQUIRE_THROW(testLinkedList->deleteNode(), out_of_range);

     // getNode --------------------------------------------
     BOOST_REQUIRE_THROW(testLinkedList->getNode(-), out_of_range);
     BOOST_REQUIRE_THROW(testLinkedList->getNode(), out_of_range);

 }

 BOOST_AUTO_TEST_CASE(LinkedList_CopyConstuctor_Test)
 {
     int arr[] = { , ,  };
     int len = sizeof(arr) / sizeof(int);
     testLinkedList->initList(arr, len);

     //LinkedList * testLinkedList2(testLinkedList);        // 特别容易写成这样，这样导致的结果就是testLinkedList2和
     //                                                     testLinkedList指向同一块内存这样的写法才是正确的
     //                                                     该句等同于
     //                                                     LinkedList * testLinkedList2;
     //                                                     testLinkedList2 = testLinkedList;
     //LinkedList testLinkedList2(*testLinkedList);        // 要不就这样子定义，只不过此时testLinkedList2不是一个指针
     LinkedList * testLinkedList3 = new LinkedList(*testLinkedList);
     BOOST_REQUIRE(testLinkedList3->getLenOfList() == );
     BOOST_REQUIRE((testLinkedList3->getNode())->data == );
     BOOST_REQUIRE((testLinkedList3->getNode())->data == );
     BOOST_REQUIRE((testLinkedList3->getNode())->data == );
     BOOST_REQUIRE((testLinkedList3->getNode())->next == NULL);
 }

 BOOST_AUTO_TEST_CASE(LinkedList_EqualOperator_Test)
 {
     int arr[] = { , ,  };
     int len = sizeof(arr) / sizeof(int);
     testLinkedList->initList(arr, len);

     // LinkedList * testLinkedList2 = testLinkedList;    // 错误的写法
     LinkedList * testLinkedList2 = new LinkedList();
     *testLinkedList2 = *testLinkedList;

     BOOST_REQUIRE(testLinkedList2->getLenOfList() == );
     BOOST_REQUIRE((testLinkedList2->getNode())->data == );
     BOOST_REQUIRE((testLinkedList2->getNode())->data == );
     BOOST_REQUIRE((testLinkedList2->getNode())->data == );
     BOOST_REQUIRE((testLinkedList2->getNode())->next == NULL);
 }

 BOOST_AUTO_TEST_SUITE_END()

BoostUnitTest.cpp

　　本篇博文的代码均托管到Taocode : http://code.taobao.org/p/datastructureandalgorithm/src/.