代码所示为模板类，无法直接编译。我感觉学习数据结构主要还是学习各种数据结构的原理，至于只用是比较简单的。

        顺序表AList是由线性表List抽象类继承来的。从代码数量上就能够看出AList类中insert和remove方法是比较重要的。将顺序表看成由两部分构成，在AList类中定义了fence属性，是为了定义当前元素的概念，同时也助于修改线性表的表示形式。

       insert函数的实现是先判断表是否达到最大的数量限制，如果是则返回false，表示不能在表中插入元素。否则从后向前遍历顺序表（因为如果从前往后的话，在赋值的时候前面的元素值就将后面的给覆盖了，后面的那个元素就无法继续向后赋值了）然后将前一个位置的元素赋给后一个位置，意思就是将顺序表从fence开始向后移动一个位置，最后将要插入元素赋给fence位置。即完成了插入操作。当然要注意将表的元素个数加一这种细节。

       remove函数也是先要判断表是否为空，若为空则无法完成移除操作。若不为空则将要移除的元素保存下来，然后遍历表，从fence位置开始，依次将后一个位置的元素赋给前一个元素，实际上相当于将想要移除的元素用后面的元素给覆盖了。

1. //List abstract class  
2. template <class Elem> class List 
3. { 
4.     public: 
5.         //virtual void clear() = 0; 
6.         virtual bool insert(const Elem&) = 0; 
7.         virtual bool append(const Elem&) = 0; 
8.         virtual bool remove(Elem&) = 0; 
9.         virtual void setStart() = 0; 
10.         virtual void setEnd() = 0; 
11.         virtual void prev() = 0; 
12.         virtual void next() = 0; 
13.         virtual int leftLength() = 0; 
14.         virtual int rightLength() = 0; 
15.         virtual bool setPos(int pos) = 0; 
16.         virtual bool getValues(Elem&) = 0; 
17.         virtual void print() const = 0;  
18. }; 
19.  
20. template <class Elem> 
21. class AList : public List<Elem> 
22. { 
23.     private: 
24.         int maxSize; 
25.         int listSize; 
26.         int fence; 
27.         Elem *listArray; 
28.     public: 
29.         AList(int size=DefaultListSize) 
30.         { 
31.             maxSize = size; 
32.             listSize = fence = 0; 
33.             listArray = new Elem[maxSize]; 
34.         } 
35.         ~AList() 
36.         { 
37.             delete [] listArray; 
38.         } 
39.         bool insert(const Elem&); 
40.         bool append(const Elem&); 
41.         bool remove(Elem&); 
42.         void setStart(); 
43.         void setEnd(); 
44.         void prev(); 
45.         void next(); 
46.         int leftLength(); 
47.         int rightLength(); 
48.         bool setPos(int pos); 
49.         bool getValues(Elem&); 
50.         void print() const;  
51. }; 
52.  
53.  
54. template <class Elem> 
55. bool  AList<Elem>::insert(const Elem& item) 
56. { 
57.     if(listSize==maxSize) 
58.         return false; 
59.     for(int i=listSize;i>fence;i--) 
60.         listArray[i] = listArray[i-1]; 
61.     listArray[fence]=item; 
62.     listSize++; 
63.     return true; 
64. } 
65.  
66. template <class Elem> 
67. bool  AList<Elem>::append(const Elem& item) 
68. { 
69.     if(listSize == maxSize) 
70.         return false; 
71.     listArray[listSize++]=item; 
72.         return true; 
73. } 
74.  
75. template <class Elem> 
76. bool AList<Elem>::remove(Elem& it) 
77. {  
78.     if(rightLength() == 0) 
79.         return false; 
80.     it=listArray[fence]; 
81.     for(int i=fence;i<maxSize;i++) 
82.         listArray[i]=listArray[i+1]; 
83.     listSize--; 
84.     return true;     
85. } 
86.  
87. template <class Elem> 
88. void AList<Elem>::setStart() 
89. { 
90.     fence=0; 
91. } 
92.  
93. template <class Elem> 
94. void AList<Elem>::setEnd() 
95. { 
96.     fence=listSize; 
97. } 
98.  
99. template <class Elem> 
100. void AList<Elem>::prev() 
101. { 
102.     if(fence!=0) 
103.         fence--; 
104. } 
105.  
106. template <class Elem> 
107. void AList<Elem>::next() 
108. { 
109.     if(fence<=listSize) 
110.         fence++; 
111. } 
112.  
113. template <class Elem> 
114. int AList<Elem>::leftLength() 
115. { 
116.     return fence; 
117. } 
118.  
119. template <class Elem> 
120. int AList<Elem>::rightLength() 
121. { 
122.     return (listSize-fence); 
123. } 
124.  
125. template <class Elem> 
126. bool AList<Elem>::setPos(int pos) 
127. { 
128.     if((pos >= 0)&&(pos <=listSize)) 
129.         fence=pos; 
130.     return ((pos >=0)&&(pos <=listSize)); 
131. } 
132.  
133. template <class Elem> 
134. bool AList<Elem>::getValues(Elem& it) 
135. { 
136.     if(listSize==0) 
137.         return false; 
138.     it=listArray[fence]; 
139.     return true; 
140. } 
141.  
142. template <class Elem> 
143. void AList<Elem>::print() const 
144. { 
145.     int temp=0; 
146.     cout<<"In AList:<"; 
147.     while(temp < fence) 
148.         cout<<listArray[temp++]<<" "; 
149.     cout<<"|"; 
150.     while(temp < listSize) 
151.         cout<<listArray[temp++]<<" "; 
152.     cout<<">\n"; 
153. }