线性表之顺序表 图解和代码实现

线性表的顺序存储结构称为顺序表。

 

图解：

 

 

下面来看下顺序表的C++实现：

SeqList.h文件

[cpp] view plain copy

1. //SeqList.h 声明类SeqList,文件名为SeqList.h  
2. #ifndef SeqList_H  
3. #define SeqList_H  
4. const int MaxSize=100;  //100只是示例性的数据，可以根据实际问题具体定义  
5. template <class T>      //定义模板类SeqList  
6. class SeqList  
7. {  
8. public:  
9.    SeqList( );       //无参构造函数  
10.    SeqList(T a[], int n);       //有参构造函数  
11.    ~SeqList();             //析构函数为空  
12.    int Length();           //求线性表的长度  
13.    T Get(int i);         //按位查找，取线性表的第i个元素  
14.    int Locate(T x);       //按值查找，求线性表中值为x的元素序号  
15.    void Insert(int i, T x);  //在线性表中第i个位置插入值为x的元素  
16.    T Delete(int i);        //删除线性表的第i个元素  
17.    void PrintList();       //遍历线性表，按序号依次输出各元素  
18. private:  
19.    T data[MaxSize];      //存放数据元素的数组  
20.    int length;            //线性表的长度  
21. };  
22. #endif  

 

SeqList.cpp文件

[cpp] view plain copy

1. //SeqList.cpp    
2. #include "SeqList.h"  
3. /* 
4. *前置条件：顺序表不存在 
5. *输    入：无 
6. *功    能：构建一个顺序表 
7. *输    出：无 
8. *后置条件：构建一个顺序表 
9. */  
10. template <class T>   
11. SeqList<T>:: SeqList( )  
12. {  
13.   length=0;  
14. }  
15. /* 
16. *前置条件：顺序表不存在 
17. *输    入：顺序表信息的数组形式a[],顺序表长度n 
18. *功    能：将数组a[]中元素建为长度为n的顺序表 
19. *输    出：无 
20. *后置条件：构建一个顺序表 
21. */  
22. template <class T>   
23. SeqList<T>:: SeqList(T a[], int n)  
24. {  
25.   if (n>MaxSize) throw "参数非法";  
26.   for (int i=0; i<n; i++)    
27.     data[i]=a[i];  
28.   length=n;  
29. }  
30. /* 
31. *前置条件：无 
32. *输    入：无 
33. *功    能：无 
34. *输    出：无 
35. *后置条件：无 
36. */  
37. template <class T>   
38. SeqList<T>:: ~SeqList( )  
39. {  
40. }  
41. /* 
42. *前置条件：顺序表存在 
43. *输    入：插入元素x,插入位置i 
44. *功    能：将元素x插入到顺序表中位置i处 
45. *输    出：无 
46. *后置条件：顺序表插入新元素 
47. */  
48. template <class T>   
49. void SeqList<T>::Insert(int i, T x)  
50. {   
51.     int j;  
52.   if (length>=MaxSize) throw "上溢";  
53.     if (i<1 || i>length+1) throw "位置";  
54.   for (j=length; j>=i; j--)  
55.   data[j]=data[j-1];   //注意第j个元素存在数组下标为j-1处  
56.   data[i-1]=x;  
57.   length++;  
58. }  
59.   
60. /* 
61. *前置条件：顺序表存在 
62. *输    入：要删除元素位置i 
63. *功    能：删除顺序表中位置为i的元素 
64. *输    出：无 
65. *后置条件：顺序表删除元素 
66. */  
67. template <class T>  
68. T SeqList<T>::Delete(int i)  
69. {   
70.     int x,j;  
71.   if (length==0) throw "下溢";  
72.   if (i<1 || i>length) throw "位置";  
73.   x=data[i-1];  
74.   for (j=i; j<length; j++)  
75.     data[j-1]=data[j];   //注意此处j已经是元素所在的数组下标  
76.   length--;  
77.   return x;  
78. }  
79. /* 
80. *前置条件：顺序表存在 
81. *输    入：无 
82. *功    能：输出顺序表长度 
83. *输    出：顺序表长度 
84. *后置条件：顺序表不变 
85. */  
86. template <class T>  
87. int SeqList<T>::Length()  
88. {  
89.      return length;  
90. }  
91. /* 
92. *前置条件：顺序表存在 
93. *输    入：查询元素位置i 
94. *功    能：按位查找位置为i的元素并输出值 
95. *输    出：查询元素的值 
96. *后置条件：顺序表不变 
97. */  
98. template <class T>   
99. T SeqList<T>::Get(int i)  
100. {  
101.   if (i<1 && i>length) throw "查找位置非法";  
102.     else return data[i-1];  
103. }  
104. /* 
105. *前置条件：顺序表存在 
106. *输    入：查询元素值x 
107. *功    能：按值查找值的元素并输出位置 
108. *输    出：查询元素的位置 
109. *后置条件：顺序表不变 
110. */  
111. template <class T>  
112. int SeqList<T>::Locate(T x)  
113. {       
114.       for (int i=0; i<length; i++)  
115.        if (data[i]==x)   
116.          return i+1 ;  //下标为i的元素等于x，返回其序号i+1  
117.       return 0;  //退出循环，说明查找失败  
118. }  
119. /* 
120. *前置条件：顺序表存在 
121. *输    入：无 
122. *功    能：顺序表遍历 
123. *输    出：输出所有元素 
124. *后置条件：顺序表不变 
125. */  
126. template <class T>  
127. void SeqList<T>::PrintList()  
128. {  
129.     for(int i=0;i<length;i++)  
130.     cout<<data[i]<<endl;  
131. }