最基本的顺序表（经典顺序表）

// 顺序表.cpp -- 最基本的顺序表（经典顺序表）
// 完整的class.

// List abstract class -- 线性表的C++抽象类声明
template<class Elem> class List()
{
public:
// Reinitialize the list. the client is responsible for
// reclaiming the storange used by the list elements.
virtual void clear() = 0;
// Insert an element at the front of the right partition.
// Return true if successful, false if the list is full.
virtual bool insert(const Elem&) = 0;
// Append an element at the end of the right partition.
// Return true if successful, false if the list is full.
virtual bool append(const Elem&) = 0;
// Remove the first element of right partition. Return
// true if successful, false if the list is empty.
// The element removed is returned in the parameter.
virtual bool remove(Elem&) = 0;
// Place fence at list start, making left partition empty.
virtual void setStart() = 0;
// Place fence at list end, making right partition empty.
virtual void setEnd() = 0;
// Move fence one step left; no change if already at start.
virtual void prev() = 0;
// Move fence one step right; no change if already at end
virtual void next() = 0;
// Return length of left partition
virtual int leftLength() const = 0;
// Return length of right partition
virtual int rightLength() const = 0;
// If pos or more elements are in the list, set the size
// of left partition to pos and return true. Otherwise,
// do nothing and return false.
virtual bool setPos(int pos) = 0;
// Return in first parameter the first element of the
// right partition. Return true if successful, false
// if the right partition is empty.
virtual bool getValue(Elem&) const = 0;
// print the contents of the list
virtual void print() const = 0;
};

// Array-based list implementation -- 线性表的实现
template <class Elem>
class Alist: public List<Elem> //继承
{
private:
int maxSize;   // Maximum size of list
int listSize;   // Actual number of elements in list
int fence;    // Position of fence
Elem* listArray;  // Array holding list elementss
public:
AList(int size = DefaultListSize) // constructor
{
maxSize = size;
lastSize = fence = 0;
listArray = new Elem[maxSize];
}
~AList() { delete [] listArray;} // Destructor

void clear()
{
delete [] listArray;
listSize = fence = 0;
listArray = new Elem[maxSize];
}
bool insert(const Elem&);
bool append(const Elem&);
bool remove(Elem&);
void setStart() { fence = 0;}
void setEnd() { fence = listSize;}
void prev()  { if (fence != 0) fence--;}
void next()  { if (fence <= listSize) fence++;}
int leftLength()const {return fence;}
int rightLength()const {return lastsize - fence;}
bool setPos(int pos)
{
if ((pos >= 0) && (pos <= listSize)) fence = pos;
return (pos >= 0) && (pos <= listSize);
}
bool getValue(Elem& it)const()
{
if (rightLength() == 0) return flase;
else { it = listArray[fence]; reutrn true;}
}
void print()const
{
int temp = 0;
cout << " < ";
while (temp < fence) cout << listArray[temp++] << " ";
cout << " | ";
while (temp < ListSize) cout << listarray[temp++] << " ";
cout << " >\n";
}
};

template <class Elem>   // Insert at front of right partition
bool Alist <Elem>::insert(const Elem& item)
{
if (listsize == maxSize) return flase; // List is full
for (int i = listsize; i > fence; i--) // Shift Elem up
listArray[i] = listArray[i-1];  // to make room
listArray[fence] = item;
listSize++;        // Increment list size
return true;
}

// Remove and return first Elem in right partition
template <class Elem> bool AList <Elem>::remove(Elem& it)
{
if (rightLength() == 0) return false; // nothing in right
it = listArray[fence];     // copy removed elem
for (int i = fence; i < listSize -1; i++) // Shift them down
listArray[i] = listArray[i + 1];
listSize--;        // Decrement Size
return true;
}

// 看完以后就觉得，原来掌握顺序表是很简单的事，只需要掌握几个点；
// 其中最重要的思想是确定位置。
// 知道现在的位置，开始的位置，结束的位置，数组的大小，该位置左右的大小。