数据结构一：线性表

线性表是最常用也是最简单的数据结构，几种常用的线性表的类模板C++描述描述如下：

1.顺序表

顺序表是将所有元素按逻辑顺序存储在一组地址连续的存储空间中的简单数据结构：

 1 const int MAXSIZE = 1000;
 2 template<class T>
 3 class SeqList
 4 {
 5 public:
 6     SeqList(){ lenght = 0; }           // 无参构造函数
 7     SeqList(const T a[], int n);       // 带参构造函数，并用数组初始化
 8
 9     int GetLenght() const{ return lenght; }// 返回顺序表长度
10     void PrintList()const;                 // 依次遍历顺序表各个数据元素
11     void Insert(int i, T x);               // 指定位置插入数据元素
12     T Delete(int i);                       // 删除指定位置的数据元素，并返回这个元素
13     T Get(int i) const;                    // 获取指定位置的数据元素
14     int Locate(T x) const;                 // 查找指定元素并返回其位置
15 private:
16     T data[MAXSIZE];                       // 存储顺序表中各个数据元素
17     int lenght;                            // 顺序表长度
18 };
19
20
21 // 构造函数
22 template<class T>
23 SeqList<T>::SeqList(const T a[], int n)
24 {
25     if (n > MAXSIZE)
26         throw"数组长度超出顺序表最大长度";
27     for (int i = 0; i < n; i++)
28         data[i] = a[i];
29     lenght = n;
30 }
31
32 // 遍历顺序表
33 template<class T>
34 void SeqList<T>::PrintList()const
35 {
36     std::cout << "顺序表中元素依次如下所示：" << endl;
37     for (int i = 0; i < lenght; i++)
38         std::cout << data[i] << " ";
39     std::cout << std::endl;
40 }
41
42 // 插入元素
43 template<class T>
44 void SeqList<T>::Insert(int i, T x)
45 {
46     if (lenght >= MAXSIZE)
47         throw"上溢异常";
48     if (i<1 || i>lenght)
49         throw"插入位置不合法";
50     for (int j = lenght; j >= i; j--)
51         data[j] = data[j - 1];
52     data[i - 1] = x;
53     lenght++;
54 }
55
56 // 删除元素
57 template<class T>
58 T SeqList<T>::Delete(int i)
59 {
60     if (0 == lenght)
61         throw"下溢异常";
62     if (i<1 || i>lenght)
63         throw"删除位置不合法";
64     T X = data[i - 1];
65     for (int j = i; j < lenght; j++)
66         data[j - 1] = data[j];
67     lenght--;
68     return X;
69 }
70
71 // 查找元素
72 template<class T>
73 T SeqList<T>::Get(int i)const
74 {
75     if (i<1 || i>lenght)
76         throw"查找位置不合法";
77
78     return data[i - 1];
79 }
80
81 // 定位元素
82 template<class T>
83 int SeqList<T>::Locate(T x)const
84 {
85     for (int i = 0; i < lenght; i++)
86     {
87         if (x == data[i])
88             return i + 1;
89     }
90
91     throw"查找的元素不存在顺序表中";
92     return 0;
93 }

2.单链表

单链表与顺序表不同的地方是存放的元素地址是零散的，可能连续也可能不连续，保证彼此之间的联系，因此，在存储元素的时候需要存储下一个元素的地址：

  1 template<class T>
  2 struct Node
  3 {
  4     T data;
  5     Node*next;
  6 };
  7
  8
  9 template<class T>
 10 class LinkList
 11 {
 12 public:
 13     LinkList(){ front = new Node<T>; front->next = NULL; }// 无参构造函数
 14     LinkList(T a[], int n);                               // 带参构造函数，用数组初始化链表
 15     ~LinkList();                                          // 析构函数
 16     void PrintList()const;                                // 依次遍历链表元素
 17     int GetLenght()const;                                 // 返回链表长度
 18     Node<T>*Get(int i)const;                              // 返回指定位置的数据元素
 19     int Locate(T x)const;                                 // 查找指定元素，并返回其位置
 20     void Insert(int i, T x);                              // 指定位置插入指定元素
 21     T Delete(int i);                                      // 删除指定位置的元素
 22 private:
 23     Node<T>*front;                                        // 头指针
 24 };
 25
 26
 27  // 头插法
 28 template<class T>
 29 LinkList<T>::LinkList(T a[], int n)
 30 {
 31     front = new Node<T>;
 32     front->next = NULL;                                   // 构造空链表
 33     for (int i = n - 1; i => 0;i--)
 34     {
 35         Node<T>*s = new Node<T>;                          // 建立新结点
 36         s->data = a[i];                                   // 将值写入结点数据域
 37         s->next = front->next;                            // 修改新节点指针域
 38         front->next = s;                                  // 修改头结点指针域
 39     }
 40 }
 41
 42 // 尾插法
 43 template<class T>
 44 LinkList<T>::LinkList(T a[], int n)
 45 {
 46     front = new Node<T>;
 47     Node<T>*r = front;
 48     for (int i = 0; i < n;i++)
 49     {
 50         Node<T>*s = new Node<T>;           // 建立新结点
 51         s->data = a[i];                    // 将值写入新结点数据域
 52         r->next = s;                       // 将新结点加入链表
 53         r = s;                             // 修改尾指针
 54     }
 55     r->next = NULL;
 56 }
 57
 58 template<class T>
 59 LinkList<T>::~LinkList()
 60 {
 61     Node<T>*p = front;                    // 初始化工作指针
 62     while (p)
 63     {
 64         front = p;                        // 暂存工作指针
 65         p = p->next;                      // 移动工作指针到下一个结点
 66         delete front;                     // 释放结点
 67     }
 68 }
 69
 70 template<class T>
 71 Node<T>*LinkList<T>::Get(int i)const
 72 {
 73     Node<T>*p = front->next;              // 初始化工作指针
 74     int j = 1;                            // 初始化计数器
 75     while (p&&j!=i)
 76     {
 77         p = p->next;                      // 移动工作指针
 78         j++;                              // 计数器递增
 79     }
 80     return p;                             // 返回查找结果
 81 }
 82
 83 template<class T>
 84 int LinkList<T>::Locate(T x)const
 85 {
 86     Node<T>*p = front->next;              // 初始化工作指针
 87     int j = 1;                            // 初始化计数器
 88     while (p)
 89     {
 90         if (x == p->data)                 // 找到指定元素就返回位置
 91             return j;
 92         p = p->next;                      // 移动工作指针
 93         j++;                              // 递增计时器
 94     }
 95     return -1;                            // 若找不到，返回-1
 96 }
 97
 98 template<class T>
 99 void LinkList<T>::Insert(int i, T x)
100 {
101     Node<T>*p = front;                    // 初始化工作指针
102
103     if (i != 1)
104         p = Get(i - 1);                   // 返回插入位置前一个元素的位置
105     if (p)
106     {
107         Node<T>*s = new Node<T>;
108         s->data = x;                      // 插入元素数据区域赋值
109         s->next = p->next;                // 插入元素指针区域赋值
110         p->next = s;                      // 插入元素接入链表
111     }
112     else
113         throw"插入位置错误！";
114 }
115
116 template<class T>
117 T LinkList<T>::Delete(int i)
118 {
119     Node<T>*p = front;                 // 初始化工作指针
120     if (i != 1)
121         p = Get(i - 1);                // 获取第i-1个元素的地址
122     Node<T>*q = p->next;               // 获取第i个元素的地址
123     p->next = q->next;                 // 将第i+1个元素与第i个元素链接
124     T x = q->data;                     // 保存被删除元素
125     delete q;                          // 删除指定位置元素
126     return x;                          // 返回被删除的元素
127 }
128
129 template<class T>
130 void LinkList<T>::PrintList()const
131 {
132     Node<T>*p = front->next;
133     std::cout << "链表元素依次为：";
134     while (p)
135     {
136         std::cout << (p->data) << " ";
137         p = p->next;
138     }
139     std::cout << std::endl;
140 }
141
142 template<class T>
143 int LinkList<T>::GetLenght()const
144 {
145     Node<T>*p = front->next;
146     int j = 1;
147     while (p)
148     {
149         p = p->next;
150         j++;
151     }
152
153     return j;
154 }

3.单循环链表

单循环链表与单链表没有太大区别，为了访问链表的首尾段，将之前的头指针换成了尾指针，尾指针指向链表尾部，尾指针指针域指向链表第一个元素：

  1 template<class T>
  2 struct Node
  3 {
  4     T data;
  5     Node*next;
  6 };
  7
  8 template<class T>
  9 class CLinkList
 10 {
 11 public:
 12     CLinkList(){ rear = new Node<T>; rear->next = rear; } // 无参构造函数
 13     CLinkList(T a[], int n);                              // 用数组初始化单循环链表
 14
 15     ~CLinkList();                                         // 析构函数
 16     int GetLenght()const;                                 // 返回链表长度
 17     Node<T>*Get(int i)const;                              // 返回指定位置元素数据
 18     int Locate(T x)const;                                 // 查找指定元素，并返回其位置
 19     void Insert(int i, T x);                              // 指定位置插入元素
 20     T Delete(int i);                                      // 删除指定位置的元素，并返回其值
 21     void PrintList()const;                                // 依次遍历链表元素
 22
 23 private:
 24     Node<T>*rear;                                         // 尾指针（指向最后一个元素）
 25 };
 26
 27
 28 template<class T>
 29 CLinkList<T>::CLinkList(T a[], int n)   // 尾插法
 30 {
 31     rear = new Node<T>;
 32     rear->next = rear;       // 初始化尾指针
 33     for (int i = 0; i < n; i++)
 34     {
 35         Node <T>*s = new Node <T>;
 36         s->data = a[i];      // 数据域赋值
 37         s->next = rear->next;// 新增结点指针指向头结点
 38         rear->next = s;      // 新增结点添加到链表中
 39         rear = s;            // 尾指针指向尾结点
 40     }
 41 }
 42
 43
 44 template<class T>
 45 void CLinkList<T>::PrintList()const
 46 {
 47     std::cout << "单循环链表各元素如下：";
 48     Node<T>*p = rear->next;              // 初始化工作指针指向头结点
 49     do
 50     {
 51         p = p->next;                     // 修改工作指针
 52         std::cout << p->data << " ";     // 打印
 53     } while (p!=rear);
 54
 55     std::cout << std::endl;
 56 }
 57
 58 template<class T>
 59 CLinkList<T>::~CLinkList()
 60 {
 61     Node<T>*p = rear->next;         // 初始化工作指针
 62     do
 63     {
 64         rear->next = p;             // 暂存待删除结点
 65         p = p->next;                // 移动工作指针
 66         delete rear->next;          // 删除结点
 67
 68     } while (p!=rear);
 69 }
 70
 71
 72 template<class T>
 73 int CLinkList<T>::GetLenght()const
 74 {
 75     Node<T>*p = rear->next;         // 初始化工作指针
 76     int j = 0;                      // 元素计数器
 77     while (p!=rear)
 78     {
 79         p = p->next;                // 移动工作指针
 80         j++;
 81     }
 82     return j;
 83 }
 84
 85 template<class T>
 86 Node<T>*CLinkList<T>::Get(int i)const
 87 {
 88     Node<T>*p = rear->next;                   // 初始化工作指针
 89     int j = 0;                                // 计数器
 90     while((p!=rear)&&(j!=i))
 91     {
 92         p = p->next;                          // 移动工作指针
 93         j++;
 94     }
 95     return p;
 96 }
 97
 98 template<class T>
 99 int CLinkList<T>::Locate(T x)const
100 {
101     Node<T>*p = rear->next;             // 初始化工作指针
102     int j = 0;                          // 计数器
103     while (p!=rear)
104     {
105         if (p->data == x)
106             return j;
107         p = p->next;                   // 移动工作指针
108         j++;
109     }
110     return -1;
111 }
112
113 template<class T>
114 T CLinkList<T>::Delete(int i)
115 {
116     Node<T>*P = rear;                  // 初始化工作指针
117     if (i != 1)
118         P = Get(i - 1);                // 获取第i-1个元素的地址
119     Node<T>*q = P->next;               // 获取第i个元素的地址
120     P->next = q->next;                 // 将第i+1个元素与第i个元素链接
121     T x = q->data;                     // 保存被删除元素
122     delete q;                          // 删除指定位置元素
123     return x;                          // 返回被删除的元素
124 }
125
126 template<class T>
127 void CLinkList<T>::Insert(int i, T x)
128 {
129     Node<T>*p = rear;
130
131     if (i != 1)
132         p = Get(i - 1);                // 获取第i-1个元素的地址
133     if (p)
134     {
135         Node<T>*s = new Node<T>;       // 新建结点数据
136         s->data = x;                   // 新增结点数据域赋值
137         s->next = p->next;             // 新增结点指针域赋值
138         p->next = s;                   // 连接链表
139     }
140     else
141         throw"插入位置错误！";
142 }

4.双向链表

相比单向链表，就是多了一个前驱结点指针，方便访问相连的前后结点：

  1 template<class T>
  2 struct DNode
  3 {
  4     T data;      // 数据域
  5     DNode*prior; // 指针域，指向前一个结点
  6     DNode*next;  // 指针域，指向后一个结点
  7 };
  8
  9 template<class T>
 10 class DLinkList
 11 {
 12 public:
 13     DLinkList(){ front = new DNode<T>; front->next = front; front->prior = front; } // 无参构造函数
 14     DLinkList(T a[], int n);                         // 带参构造函数，数组初始化链表
 15     ~DLinkList();                                    // 析构函数
 16
 17     void Insert(int i, T X);                         // 指定位置插入指定元素
 18     T Delete(int i);                                 // 删除指定位置的元素，并返回这个元素
 19     int GetLenght()const;                            // 返回链表长度
 20     DNode<T>*Get(int i)const;                        // 查找指定位置元素
 21     int Locate(T X)const;                            // 查找指定元素，并返回其位置
 22     void PrintList()const;                           // 遍历链表
 23 private:
 24     DNode<T>*front;
 25 };
 26
 27 template<class T>
 28 DLinkList<T>::DLinkList(T a[], int n)
 29 {
 30     front = new DNode<T>;                 // 构造头结点
 31     DNode<T>*p = front;                   // 存储头指针
 32     front->next = front;                  // 初始化头结点
 33     front->prior = front;                 // 初始化头结点
 34
 35     for (int i = 0; i < n;i++)
 36     {
 37         DNode<T>*s = new DNode<T>;        // 构造新结点数据结构
 38         s->data = a[i];                   // 给新结点数据域赋值
 39         s->next = front->next;            // 新结点后驱指针指向头结点
 40         front->next = s;                  // 新结点加入后驱链中
 41         s->prior = front;                 // 新结点前驱指针指向头结点
 42         p->prior = s;                     // 修改头结点前驱指针指向新结点
 43
 44         front = s;                        // 传递尾结点地址到下一个结点
 45     }
 46     front = p;                            // 修改头指针指向头结点
 47 }
 48
 49 template<class T>
 50 DLinkList<T>::~DLinkList()
 51 {
 52     DNode<T>*p = front;                   // 初始化工作结点
 53     DNode<T>*q = front;                   // 初始化工作结点
 54     do
 55     {
 56         p = p->next;                      // 移动工作结点
 57         q = p;                            // 暂存待释放结点
 58         delete q;
 59     } while (p!=front->prior);
 60
 61     delete front;                          // 释放头结点
 62 }
 63
 64 template<class T>
 65 void DLinkList<T>::PrintList()const
 66 {
 67     DNode<T>*p = front;                    // 初始化工作链表
 68     std::cout << "按后驱指针遍历链表：";
 69     while(p!=front->prior)
 70     {
 71         p = p->next;                       // 移动工作指针
 72         std::cout << p->data << " ";
 73     }
 74     std::cout << std::endl;
 75
 76     DNode<T>*q = front->prior;             // 初始化工作链表
 77     std::cout << "按前驱指针遍历链表：";
 78     while (p != front)
 79     {
 80         std::cout << p->data << " ";
 81         p = p->prior;                       // 移动工作指针
 82     }
 83     std::cout << std::endl;
 84 }
 85
 86 template<class T>
 87 T DLinkList<T>::Delete(int i)
 88 {
 89     DNode<T>*p = Get(i);           // 获取待删除结点地址
 90     DNode<T>*p1 = p->prior;        // 获取待删除结点的前驱结点位置
 91     DNode<T>*p2 = p->next;         // 获取待删除结点的后驱结点位置
 92     T x = p->data;                 // 暂存待删除结点数据域
 93     p1->next = p2;                 // 修改后驱链
 94     p2->prior = p1;                // 修改前驱链
 95
 96     delete p;                      // 删除结点
 97
 98     return x;
 99 }
100
101 template<class T>
102 void DLinkList<T>::Insert(int i, T X)
103 {
104     DNode<T>*p = Get(i);                // 获取待插入位置地址
105     if (p)
106     {
107         DNode<T>*s = new DNode<T>;      // 构造新结点数据存储结构
108         DNode<T>*q = p->prior;          // 获取待插入位置的前驱结点位置
109
110         s->data = X;                    // 插入的新结点数据域赋值
111         s->next = p;                    // 插入结点的后驱指针赋值
112         q->next = s;                    // 插入结点的前一结点的后驱指针赋值
113         s->prior = q;                   // 插入结点的前驱指针赋值
114         p->prior = s;                   // 插入结点的后一节点的前驱指针赋值
115     }
116     else throw"插入位置错误";
117 }
118
119 template<class T>
120 int DLinkList<T>::GetLenght()const
121 {
122     DNode<T>*p = front;                  // 初始化工作指针
123     int j = 0;                           // 定义一个计数器
124     while (p!=front->prior)
125     {
126         p = p->next;                     // 移动工作指针
127         j++;
128     }
129     return j;
130 }
131
132 template<class T>
133 DNode<T>*DLinkList<T>::Get(int i)const
134 {
135     DNode<T>*p = front;              // 初始化工作指针
136     int j = 0;                       // 定义一个计数器
137     while ((p!=front->prior)&&j!=i)
138     {
139         p = p->next;                 // 移动工作指针
140         j++;
141     }
142     return p;                        // 找到返回地址
143 }
144
145 template<class T>
146 int DLinkList<T>::Locate(T X)const
147 {
148     DNode<T>*p = front;              // 初始化工作结点
149     int j = 0;
150     while (p!=front->prior)
151     {
152         p = p->next;                 // 移动工作指针
153         j++;
154         if (p->data == X)
155             return j;                // 找到元素，返回位置
156     }
157     return -1;                       // 找不到返回-1
158 }

5.静态链表

静态链表主要是为了满足那些没有“指针”这一类数据类型的语言（JAVA,BASIC等），采用数组来模拟链表，数组的下标来模拟指针：

  1 template<class T>
  2 struct StaticNode
  3 {
  4     T data;            // 数据域
  5     int next;          // 游标（模拟指针）
  6 };
  7
  8 const int SLISTMAXSIZE = 100;
  9
 10 template<class T>
 11 class StaticLinkList
 12 {
 13 public:
 14     StaticLinkList();                     // 无参构造函数
 15     StaticLinkList(T a[], int n);         // 带参构造函数，数组初始化链表
 16     void Insert(int i, T X);              // 指定位置插入指定元素
 17     T Delete(int i);                      // 删除指定位置元素，并返回该元素
 18     int Get(int i)const;                  // 按位查找，返回下标
 19     int Locate(T X)const;                 // 按值查找，返回下标
 20     int GetLenght()const;                 // 返回链表长度
 21     int NewNode();                        // 申请结点空间
 22     void DeleteNode(int i);               // 释放指定结点
 23     void PrintList()const;                // 遍历链表
 24 private:
 25     int front;                            // 数据域起始下标
 26     int tail;                             // 空闲域起始下标
 27     StaticNode<T> Sarray[SLISTMAXSIZE];        // 数据表
 28 };
 29
 30
 31 template<class T>
 32 StaticLinkList<T>::StaticLinkList()
 33 {
 34     for (int i = 0; i < SLISTMAXSIZE - 1; i++)
 35         Sarray[i].next = i + 1;            // 链表每个游标都是指向下一个数组元素
 36     Sarray[SLISTMAXSIZE - 1].next = -1;         // 将最后一个元素的游标指向-1
 37     tail = 0;                             // 显然空链表的头结点下标就是0
 38     front = -1;                           // 空链表的头结点游标定义为-1
 39 }
 40
 41 template<class T>
 42 StaticLinkList<T>::StaticLinkList(T a[], int n)
 43 {
 44     // 初始化数组
 45     if (n > SLISTMAXSIZE)
 46         throw"数据溢出";
 47     for (int i = 0; i < SLISTMAXSIZE - 1; i++)
 48         Sarray[i].next = i + 1;             // 链表中每个游标指向下一个数组元素
 49     Sarray[SLISTMAXSIZE - 1].next = -1;          // 将最后一个元素的游标指向-1
 50     for (int i = 0; i < n; i++)
 51         Sarray[i].data = a[i];              // 给链表数据域赋值
 52     front = 0;                             // front指向可用数据域的第一个元素的下标
 53     tail = Sarray[n - 1].next;              // tail指向未分配空间的第一个元素
 54     Sarray[n - 1].next = -1;                // 将可用数据域最有一个元素的游标指向-1
 55 }
 56
 57 template<class T>
 58 int StaticLinkList<T>::NewNode()
 59 {
 60     if (-1 == tail)                         // 判断是否还有未分配空间
 61         throw"内存不足";
 62     int pos=tail;                           // 未分配空间第一个结点分配给新结点
 63     tail = Sarray[tail].next;               // 未分配空间起点游标后移
 64     Sarray[tail].next = -1;                 // 修改数据域最后一个元素指向-1
 65     return pos;                             // 返回新结点的下标
 66 }
 67
 68 template<class T>
 69 void StaticLinkList<T>::DeleteNode(int i)
 70 {
 71     if (i<0 || i>SLISTMAXSIZE - 1 || -1 == front)
 72         throw"释放空间错误";
 73     int p = Get(i);                             // 记录第i个元素下标
 74     int q = Get(i - 1);;                        // 记录第i-1个元素的下标
 75     if (p==front)                               // 单独处理删除点为头结点的情况
 76     {
 77         Sarray[front].next = tail;
 78         tail = front;                           // 删除的结点插入到未使用空间的头结点位置
 79         front = Sarray[front].next;             // 更改数据域的起始下标为原来的下一个位置
 80     }
 81     else if (-1 == Sarray[p].next)              // 单独处理待删除点为尾结点的情况
 82     {
 83         Sarray[p].next = tail;
 84         tail = p;
 85         Sarray[q].next = -1;
 86     }
 87     else                                        // 一般情况处理
 88     {
 89         Sarray[q].next = Sarray[p].next;
 90         Sarray[p].next = tail;
 91         tail = p;
 92     }
 93 }
 94
 95 template<class T>
 96 T StaticLinkList<T>::Delete(int i)
 97 {
 98     T x = Sarray[Get(i)].data;   // 将待删除元素暂存
 99     DeleteNode(i);               // 删除元素
100
101     return x;
102 }
103
104 template<class T>
105 void StaticLinkList<T>::Insert(int i, T X)
106 {
107     int p = Get(i);                       // 记录第i个元素的下标
108     if (p < 0)
109         throw"插入位置错误";
110
111     if (p==front)                         // 单独处理在头结点插入的情况
112     {
113         Sarray[tail].data = X;            // 从未分配空间第一个元素开始使用
114         Sarray[tail].next = front;        // 新结点与后一结点链接
115         front = tail;                     // 更新头结点
116         tail = Sarray[tail].next;         // 未分配空间的头结点顺移
117     }
118     else
119     {
120         int q = Get(i - 1);               // 记录第i-1个元素下标
121
122         Sarray[tail].data = X;            // 从未分配空间第一个元素开始使用
123         Sarray[q].next = tail;            // 新结点与前一结点链接
124         Sarray[tail].next = p;            // 新结点与后一结点链接
125         tail = Sarray[tail].next;         // 未分配空间的头结点顺移
126     }
127 }
128
129 template<class T>
130 int StaticLinkList<T>::Get(int i)const
131 {
132     if (i<0 || i>GetLenght())
133         return -1;               // 找不到就返回错误-1
134     int p = front;               // 初始化工作指针
135     int j = 1;                   // 计数器
136     while (p!= -1)
137     {
138         if (j == i)
139             return p;
140         p = Sarray[p].next;      // 移动工作指针
141         j++;
142     }
143     return p;
144 }
145
146 template<class T>
147 int StaticLinkList<T>::GetLenght()const
148 {
149     if (-1 == front)
150         throw"长度为0";
151
152     int j = 0;                  // 计数器
153     int k = front;              // 工作指针
154     while (k!=-1)
155     {
156         k = Sarray[k].next;     // 移动工作指针
157         j++;
158     }
159     return j;
160 }
161
162 template<class T>
163 int StaticLinkList<T>::Locate(T X)const
164 {
165     int p = front;                      // 工作指针
166     while (p!=-1)
167     {
168         if (X == Sarray[p].data)        // 找到就返回下标
169             return p;
170         p = Sarray[p].next;
171     }
172     return -1;
173 }
174
175 template<class T>
176 void StaticLinkList<T>::PrintList()const
177 {
178     int p = front;                   // 工作游标
179     std::cout << "链表元素依次如下：";
180     while (p!=-1)
181     {
182         std::cout << Sarray[p].data << " ";
183         p = Sarray[p].next;          // 移动工作游标
184     }
185     std::cout << std::endl;
186 }