"《算法导论》之‘线性表’"：基于静态分配的数组的顺序表

　　首先，我们来搞明白几个概念吧（参考自网站数据结构及百度百科）。

　 线性表

　　线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。线性表的逻辑结构简单，便于实现和操作。在实现线性表数据元素的存储方面，一般可用顺序存储结构和链式存储结构两种方法。

　 顺序表

　　用顺序存储方法存储的线性表简称为顺序表（Sequential List）。顺序表的存储方法是把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里。

　 链表

　　链接方式存储的线性表简称为链表（Linked List）。

　　顺序表和链表的比较如下：

　　　

　　注：存储密度（Storage Density）是指结点数据本身所占的存储量和整个结点结构所占的存储量之比，即“存储密度=（结点数据本身所占的存储量）/（结点结构所占的存储总量）”。

　　下文将具体讲述如何实现基于静态分配的数组的顺序表：

　　具体算法可以参考网页顺序表上实现的基本运算及Larry Nyhoff的《数据结构与算法分析》。我的做法基本跟他们是一样的，只是我又额外多了一部分：Boost单元测试。对于如何进行Boost单元测试可以参考本人之前写过的一篇文章如何在VS2013中进行Boost单元测试。

　　我设计的顺序表类如下：

 // seqlist.h
 1 #ifndef SEQLIST
 #define SEQLIST

 #include <iostream>
 #include <cassert>
 #include <algorithm>

 using namespace std;

 const int CAPACITY = ;
 typedef int ElementType;

 class SeqList
 {
 public:
     SeqList();
     virtual ~SeqList();
     bool empty() const;
     void clear();
     bool insert(const int pos, const ElementType val);
     bool erase(const int pos);
     void display() const;
     bool setSeqList(const ElementType *tmpList, const int len);
     int getLenOfList() const;
     ElementType getItem(const int pos);
     ElementType * getSeqList();    // 保留，不推荐使用，因为在使用过程中无法进行越界检查

 private:
     int lenOfList;    　　　　　　　　// 线性链表长度
     ElementType seqList[CAPACITY];

 };

 #endif

 // seqlist.cpp
 #include "seqlist.h"

 SeqList::SeqList()
 {
     // initialization
     lenOfList = ;
     fill(seqList, seqList + CAPACITY - , );
     // memset(SeqList, 1, CAPACITY*sizeof(int));
 }

 SeqList::~SeqList()
 {

 }

 bool SeqList::empty() const
 {
     return lenOfList == ;
 }

 void SeqList::clear()
 {
     lenOfList = ;
     fill(seqList, seqList + CAPACITY - , );
 }

 bool SeqList::insert(const int pos, const ElementType val)
 {
     bool success = false;
     // assert(lenOfList != CAPACITY);    // 这里的assert分成两行写，是为了方便定位错误发生的地方
     // assert(0 <= pos <= lenOfList);
     if (lenOfList == CAPACITY)
     {
         cerr << "No space for insertion!" << endl;
     }
     else if (pos <  || pos > lenOfList)
     {
         cerr << "The position " << pos <<
             " you want to insert is less than zero or exceeds the length of the list!" << endl;
         throw out_of_range("throw out_of_range");    // 抛出一个越界异常
     }
     else
     {
         int tmpCount = lenOfList - pos;
         for (int i = ; i < tmpCount; i++)
         {
             seqList[lenOfList - i] = seqList[lenOfList - i - ];
         }
         seqList[pos] = val;
         lenOfList++;
         success = true;
     }
     return success;
 }

 bool SeqList::erase(const int pos)
 {
     bool success = false;
     // assert(lenOfList != 0);
     // assert(0 <= pos <= lenOfList);
     if (lenOfList == )
     {
         cerr << "There is no elements in the list!" << endl;
     }
     else if (pos <  || pos > lenOfList)
     {
         cerr << "The position " << pos <<
             " you want to erase is less than zero or exceeds the length of the list!" << endl;
         throw out_of_range("throw out_of_range");    // 抛出一个越界异常
     }
     else
     {
         int tmp = lenOfList - pos;
         for (int i = ; i < tmp - ; i++)
         {
             seqList[pos + i] = seqList[pos + i + ];
         }
         seqList[lenOfList - ] = ;
         lenOfList--;
         success = true;
     }
     return success;
 }

 void SeqList::display() const
 {
     cout << "***Start Displaying***" << endl;
     if (lenOfList == )
     {
         cerr << "There is no element in the the list!" << endl;
     }
     else
     {
         for (int i = ; i < lenOfList; i++)
         {
             cout << i << " : " << seqList[i] << endl;
         }
         cout << "***End Displaying***" << endl;
     }
 }

 bool SeqList::setSeqList(const ElementType *tmpList, const int len)
 {
     // assert(len <= CAPACITY);
     bool success = false;
     if (len <= CAPACITY)
     {
         for (int i = ; i < len; i++)
         {
             seqList[i] = *(tmpList++);
         }
         lenOfList = len;
         success = true;
     }
     else
     {
         cerr << "The length of the array you set exceeds the CAPACITY." << endl;
         throw out_of_range("throw out_of_range");    // 抛出一个越界异常
     }
     return success;
 }

 int SeqList::getLenOfList() const
 {
     return lenOfList;
 }

 ElementType SeqList::getItem(const int pos)
 {
     // assert(0 <= pos <= lenOfList);
     if (pos <  || pos > lenOfList)
     {
         cerr << "The item at " << pos << " you want to get does not exist!" << endl;
         throw out_of_range("throw out_of_range");    // 抛出一个越界异常
     }
     else
     {
         return seqList[pos];
     }
 }

 ElementType * SeqList::getSeqList()
 {
     return seqList;
 }

seqlist.cpp

　　单元测试所用到的代码如下：

 // BoostUnitTest.cpp
 #define  BOOST_TEST_MODULE ArrayList_Test_Module

 #include "stdafx.h"
 #include "D:\VSProject\Algorithm\List\SeqList\SeqList\SeqList\seqlist.h"

 struct ArrayList_Fixture
 {
     ArrayList_Fixture()
     {
         BOOST_TEST_MESSAGE("Setup fixture");
         testArrayList = new SeqList();
     }
     ~ArrayList_Fixture()
     {
         BOOST_TEST_MESSAGE("Teardown fixture");
         delete testArrayList;
     }

     SeqList * testArrayList;
 };

 // BOOST_AUTO_TEST_SUITE(ArrayList_Test_Suite)
 BOOST_FIXTURE_TEST_SUITE(ArrayList_Test_Suite, ArrayList_Fixture)

 BOOST_AUTO_TEST_CASE(ArrayList_Abnormal_Test)
 {
     // Set values to the array list
     int testArray[] = { , , , ,  };    // 5 个元素
     int testLenOfList = sizeof(testArray) / sizeof(int);
     testArrayList->setSeqList(testArray, testLenOfList);
     // BOOST_REQUIRE_THROW(testArrayList->setArrayList(testArray, testLenOfList), out_of_range);

     // Method getItem-----------------------------------------------
     // If the position of the item you want to get is less than zero
     BOOST_REQUIRE_THROW(testArrayList->getItem(-), out_of_range);
     // If the position of the item you want to get is larger than the length of the list
     BOOST_REQUIRE_THROW(testArrayList->getItem(), out_of_range);

     // Method insert-------------------------------------------------
     // If the inserting position is less than zero
     BOOST_REQUIRE_THROW(testArrayList->insert(-, ), out_of_range);
     BOOST_REQUIRE(testArrayList->getLenOfList() == testLenOfList);

     // If the inserting position is larger than the length of the list
     BOOST_REQUIRE_THROW(testArrayList->insert(, ), out_of_range);
     BOOST_REQUIRE(testArrayList->getLenOfList() == testLenOfList);

     // Method erase-------------------------------------------------
     // If the erasing position is less than zero
     BOOST_REQUIRE_THROW(testArrayList->erase(-), out_of_range);
     BOOST_REQUIRE(testArrayList->getLenOfList() == testLenOfList);

     // If the erasing position is larger than the length of the list
     BOOST_REQUIRE_THROW(testArrayList->erase(), out_of_range);
     BOOST_REQUIRE(testArrayList->getLenOfList() == testLenOfList);

 }

 BOOST_AUTO_TEST_CASE(ArrayList_Normal_Test)
 {
     bool expected;
     bool actual;
     // Method empty-------------------------------------------------
     expected = true;
     actual = testArrayList->empty();
     BOOST_REQUIRE(expected == actual);

     // Set values to the array list
     int testArray[] = { , , , ,  };    // 5 个元素
     int testLenOfList = sizeof(testArray) / sizeof(int);
     testArrayList->setSeqList(testArray, testLenOfList);
     // BOOST_REQUIRE_THROW(testArrayList->setArrayList(testArray, testLenOfList), out_of_range);

     // Method getItem-----------------------------------------------
     BOOST_REQUIRE(testArrayList->getItem() == testArray[]);

     // Method empty-------------------------------------------------
     expected = false;
     actual = testArrayList->empty();
     BOOST_REQUIRE(expected == actual);

     // Method insert-------------------------------------------------
     expected = true;
     actual = testArrayList->insert(, );
     BOOST_REQUIRE(expected == actual);
     BOOST_REQUIRE(testArrayList->getLenOfList() == testLenOfList + );
     BOOST_REQUIRE(testArrayList->getItem() == );

     // Method erase-------------------------------------------------
     expected = true;
     actual = testArrayList->erase();
     BOOST_REQUIRE(expected, actual);
     BOOST_REQUIRE(testArrayList->getLenOfList() == testLenOfList);
     BOOST_REQUIRE(testArrayList->getItem() == testArray[]);

 }

 BOOST_AUTO_TEST_SUITE_END();

BoostUnitTest.cpp

　　我在单元测试中偏向于使用REQUIRE型的判断，这样方便我检测出问题出现在哪。另外，我在单元测试中偏向于按“正常测试”和“不正常测试”两类进行测试。

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