<C/C++数据结构>顺序表

一，顺序表的基本概念：

顺序表一般表现为数组，使用一组地址 连续 的存储单元依次存储数据元素，如图所示。它具有如下特点：

• 长度固定，必须在分配内存之前确定数组的长度。
• 存储空间连续，即允许元素的随机访问。
• 存储密度大，内存中存储的全部是数据元素。
• 要访问特定元素，可以使用索引访问，时间复杂度为 O(1)。
• 要想在顺序表中插入或删除一个元素，都涉及到之后所有元素的移动，因此时间复杂度为 $O(n)$。

二，顺序表的c++模板实现

注模板的声明文件（.h）和定义文件（.cpp）建议不要分开！！！

1，seqList.h的代码：

1. #include <iostream>  
2.   
3. /***************线性表数据结构***************/  
4.   
5. template <typename DataType>   
6. class SeqList  
7. {  
8. public:  
9.     //构造函数，初始化数组以及数组长度  
10.     SeqList(int size=defaultSize)  
11.     {  
12.         if(size >0)                         //检查赋予的顺序表大小，如果合法则分配相应大小的内存  
13.         {  
14.             maxSize = size;  
15.             length = 0;  
16.             elements = new DataType[maxSize];  //分配顺序表的内存大小  
17.             for(int i = 0;i<maxSize;i++)  
18.                 elements[i] = NULL;   //初始化  
19.         }  
20.         else  
21.         {  
22.             cout<<"Error Length of SeqList!"<<endl;  
23.         }  
24.     }  
25.     //析构函数  
26.     ~SeqList()  
27.     {  
28.         //delete[] elements;                //回收顺序表的内存空间  
29.     }  
30.   
31.     //插入元素  
32.     bool InsertElement(DataType data);   //向表尾插入新元素  
33.     //获取元素  
34.     DataType GetElement(int location);    //返回指定位置的元素  
35.     //删除元素  
36.     bool DelElement(int location);   //删除指定元素  
37.     //更改指定元素  
38.     bool ChangeElement(int location,DataType data);  
39.     //打印顺序表  
40.     bool PrintList();  
41.     //查找指定元素，并返回其在表中的位置    
42.     int FindElement(DataType data);      //返回匹配的第一个元素的位置（位置是一个整数值哈！！）    
43.     //判断顺序表是否为空  
44.     bool IsEmpty(SeqList L) ;  
45.     //初始化书序表  
46.     bool InitList(int nLen);  
47.     //清空顺序表  
48.     void ClearList(SeqList *L);    
49.     //销毁顺序表  
50.     void DestroyList();    
51.     void ConverseList();   
52.     //获取顺序表长度  
53.     int getLength()  
54.     {  
55.         return length;  
56.     }  
57.       
58.       
59. private:  
60.     static const int defaultSize = 10;//顺序表的默认长度，只有静态变量才能在类中初始化  
61.     DataType *elements;  
62.     int maxSize;                         //顺序表最大大小  
63.     int length;                          //顺序表的当前有效长度  
64.   
65. };  

2，seqList.cpp的代码：

[html]  view plain copy print ?

1. <pre name="code" class="html">#include "stdafx.h"  
2. #include <iostream>  
3. #include "seqList.h"  
4.   
5. /***************顺序表插入操作********************/  
6. template <typename DataType>  
7. bool SeqList<DataType>::InsertElement(DataType data)  
8. {  
9.   
10.     int curIndex = length;    //记录新元素的插入位置  
11.     if(length >= maxSize)         //判断顺序表是否已满  
12.     {  
13.         return false;                             //顺序表已满，返回false，插入不成功  
14.     }  
15.     else  
16.     {  
17.   
18.         elements[curIndex] = data;      //将新元素插入顺序表表尾  
19.         length++;                        //顺序表有效长度加1      
20.         return true;  
21.     }  
22. }  
23.   
24. template <typename DataType>   
25. bool SeqList<DataType>:: InitList(int nLen)  
26. {  
27.     DataType nchar='A';  
28.     for(int i = 0;i<nLen;i++)  
29.     {  
30.         InsertElement(nchar++);           //插入数据实现初始化  
31.     }  
32.     return true;  
33. }  
34.   
35. template <typename DataType>   
36. DataType SeqList<DataType>::GetElement(int location)  
37. {  
38.     if(location<0 || location>length)              //判断位置索引是否合法  
39.     {  
40.         std::cout<<"参数无效"<<std::endl;  
41.         return 0;  
42.     }  
43.     else  
44.     {  
45.         return elements[location];                //返回指定位置的元素  
46.     }  
47. }  
48.   
49. template <typename DataType>   
50. bool SeqList<DataType>:: DelElement(int location)  
51. {  
52.     if(location<0 || location>length)              //判断位置索引是否合法  
53.     {  
54.         std::cout<<"参数无效"<<std::endl;  
55.         return false;  
56.     }  
57.     else  
58.     {  
59.         int j=0;  
60.         for (int i=location;i<length;i++)  
61.         {  
62.             elements[location+j-1]=elements[location+j];                //铲除指定位置的元素  
63.             j++;  
64.         }  
65.         length--;  
66.         return true;  
67.     }  
68. }  
69.   
70. template <typename DataType>   
71. bool SeqList<DataType>:: ChangeElement(int location,DataType data)  
72. {  
73.     if(location<0 || location>length)              //判断位置索引是否合法  
74.     {  
75.         std::cout<<"参数无效"<<std::endl;  
76.         return false;  
77.     }  
78.     else  
79.     {  
80.         elements[location-1]=data;  
81.         return true;  
82.     }  
83. }  
84.   
85.   
86. template <typename DataType>   
87. bool SeqList<DataType>:: PrintList()  
88. {  
89.     //输出初始化后的顺序表  
90.     for(int i = 0;i<length;i++)  
91.         cout<<GetElement(i)<<" ";  
92.     cout<<endl;  
93.     return true;  
94. }  
95.   
96. template <typename DataType>   
97. int SeqList<DataType>:: FindElement(DataType data)  
98. {  
99.     //输出初始化后的顺序表  
100.     for(int i = 0;i<length;i++)  
101.     {   if (elements[i]==data)  
102.         {  
103.             return i;  
104.         }  
105.     }  
106.     cout<<"没有改元素"<<endl;  
107.     return 0;  
108. }  
109.   
110. /**************判断顺序表是否为空，若是则返回真********************/    
111. template<typename DataType>     
112. bool SeqList<DataType>::IsEmpty(SeqList<DataType> L)    
113. { /* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */    
114.     if(L.length==0)    
115.         return true;    
116.     else    
117.         return false;    
118. }   
119.   
120. template<typename DataType>     
121. void SeqList<DataType>::ClearList(SeqList *L)    
122. {     
123.     for(int i = 0;i<length;i++)  
124.         elements[i] = 0;   //初始化  
125.     L->length=0;  
126.     L->maxSize=0;  
127. }   
128.   
129. /**************销毁顺序表********************/  //  
130. template<typename DataType>     
131. void SeqList<DataType>::DestroyList()    
132. {     
133.     //初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L    
134.     length=0;    
135.     maxSize=0;    
136.     delete[] elements; //这句话不要再出现在析构函数中了  
137.     elements=NULL;    
138. }    
139.   
140. /**************逆序顺序表********************/   
141. template<typename DataType>     
142. void SeqList<DataType>::ConverseList()    
143. {     
144.     for (int i=0;i<length/2;i++)  
145.     {  
146.         DataType temp;  
147.         temp=elements[i];  
148.         elements[i]=elements[length-1-i];  
149.         elements[length-1-i]=temp;  
150.     }  
151. }    

3，主函数测试代码如下：

[cpp]  view plain copy print ?

1. <pre name="code" class="html">// ConsoleAppMySeqList.cpp : 定义控制台应用程序的入口点。  
2. //  
3.   
4. #include "stdafx.h"  
5. #include "seqList.cpp"  
6. #include "windows.h"  
7. using namespace std;  
8.   
9. typedef char Mytype;  
10. int _tmain(int argc, _TCHAR* argv[])  
11. {  
12.     int nLen=0;  
13.     cout<<"请输入链表的长度:   ";  
14.     cin>>nLen;  
15.     SeqList<Mytype> list(nLen);                  //建立1个顺序表,长度为nLen，链表元素类型为Mytype  
16.     list.InitList(nLen);  
17.     cout<<"初始化后的内容为;(亲，萌妹纸自动帮您完成的哦！！！)"<<endl;  
18.     list.PrintList();  
19.     int nPos=0;  
20.     cout<<"你想删除那个位置的元素（位置从1开始算起）  ";  
21.     cin>>nPos;  
22.     while (true)  
23.     {  
24.         if (nPos>list.getLength())  
25.         {  
26.             cout<<"输入过大，重新输入（位置从1开始算起）"<<endl;  
27.             cin>>nPos;  
28.         }else  
29.         {  
30.             break;  
31.         }  
32.     }  
33.     list.DelElement(nPos);  
34.     //输出初始化后的顺序表  
35.     list.PrintList();  
36.   
37.     cout<<"现在顺序表的长度为：  "<<endl;  
38.     cout<<list.getLength()<<endl;  
39.   
40.     Mytype mchar='0';  
41.     int nPos1=0;  
42.     char ans='n';  
43.     do   
44.     {  
45.         cout<<"请输入您想改变的指定位置和相应元素(示例：“k 5”)  ";  
46.         cin>>mchar>>nPos1;  
47.         list.ChangeElement(nPos1,mchar);  
48.         cout<<"继续更改？（y/n）  "<<endl;  
49.         cin>>ans;  
50.     } while (ans=='y'||ans=='Y');  
51.   
52.     cout<<"更改后的顺序表为："<<endl;  
53.     list.PrintList();  
54.     cout<<"执行逆序："<<endl;  
55.     list.ConverseList();  
56.     list.PrintList();  
57.   
58.     Mytype bchar='0';  
59.     cout<<"请输入您想查找的元素:  ";  
60.     cin>>bchar;  
61.     int npos2=list.FindElement(bchar);  
62.     cout<<"您查找的元素的位置为："<<endl;  
63.     cout<<npos2<<endl;  
64.   
65.     list.ClearList(&list);  
66.     if (list.IsEmpty(list)==true)  
67.     {  
68.         cout<<"顺序表已被清空"<<endl;  
69.     }else  
70.     {  
71.         cout<<"顺序表还有元素"<<endl;  
72.     }  
73.     cout<<"5秒后执行销毁命令.........."<<endl;  
74.     Sleep(1000);  
75.     cout<<"4秒后执行销毁命令.........."<<endl;  
76.     Sleep(1000);  
77.     cout<<"3秒后执行销毁命令.........."<<endl;  
78.     Sleep(1000);  
79.     cout<<"2秒后执行销毁命令.........."<<endl;  
80.     Sleep(1000);  
81.     cout<<"1秒后执行销毁命令.........."<<endl;  
82.     Sleep(1000);  
83.     cout<<"再见，谢谢.........."<<endl;  
84.     list.DestroyList();  
85.     system("PAUSE");  
86.     return 0;  
87. }  

4，测试结果

参考资源：

【1】《百度百科》

【2】http://zh.wikipedia.org/wiki/顺序表