顺序表简介
特点：
1、使用一组地址连续的存储单元依次存储表中的数据元素，常见的就是使用数组去实现。
2、顺序表中逻辑相邻的数据元素，在物理内存上也相邻。
3、顺序表中的任意数据元素都可随机访问，即访问一个数据元素的时间复杂度为O(1)。
假设每个数据元素的占用内存大小为L，表中第一个数据元素的地址为LOC(a1)，难么第i个元素的地址就可以直接计算出来：LOC(ai) = LOC(a1) + (i-1)*L，这是顺序表支持随机访问的基本依据。
优点：访问表中的元素很快，时间复杂度为O(1)。
缺点：插入，删除元素需要移动大量的元素，时间复杂度为O(n) 。
因此如果我们在编程中需要这样一种线性表数据结构：构造后对元素的访问操作很频繁，而很少进行增，删等元素位置的调整操作，那么就可以考虑使用顺序表。
代码实现
#include<iostream> #include<stdexcept> #include<cstdlib> using namespace std; class ArrayList { private: enum{ INCREMENT_SIZE = 20, //容量不足时，每次增加10个 INIT_CAPACITY = 10 //初始容量20 }; int size; //实际元素个数 int capacity; //容量 int* elements; //存储元素的数组的基地址 //确保表的容量至少为 reqCapacity 个。否则就增加容量 。 void ensureCapacity(int reqCapacity) { int* nelements; if(capacity<reqCapacity) { nelements = (int*)realloc(elements,(capacity+INCREMENT_SIZE)*sizeof(int)); if(nelements!=0) //如果对动态数组的大小调整成功 { elements = nelements; capacity+=INCREMENT_SIZE; } /* else{ //调整失败 exit(-1); } */ } } public: ArrayList():size(0),capacity(INIT_CAPACITY),elements(0) { elements = (int*)malloc(sizeof(int)*INIT_CAPACITY); } ~ArrayList() { free(elements); } /* * 功能:在表末尾追加元素 */ void append(int e) { ensureCapacity(size+1); elements[size++] = e; } /* * 将新元素e插入为索引为index * 合法的index值为 [0,size] ，当index为size时，不需要移动元素，当index为0时 * 需要移动所有元素。 * **/ bool insert(int index,int e) { if(index>size || index < 0) return false; //索引不合法 ensureCapacity(size+1); for(int i=size-1;i>=index;--i) { elements[i+1] = elements[i]; } elements[index] = e; size++; return true; } /* * 删除索引为index 的元素 。 * 合法的index值为 [0,size-1] ，当index=0时，删除的是第一个元素。 * 当index为size-1时，删除的是最后一个元素 **/ bool remove(int index) { if(index>=size || index <0) return false; //索引不合法 for(int i=index;i<size-1;++i) { elements[i] = elements[i+1]; } size --; return true; } /* * 功能：查找一个元素在表中的索引，如果不存在此元素，则返回-1 */ int indexOf(int e) const { for(int i=0;i<size;++i) { if(elements[i] == e) return i; } return -1; } /* * 功能:判断表中是否包含某个元素。 */ bool contains(int e) const { return (-1 != indexOf(e)); } int length() const { return size; } void clear() { size = 0; } bool isEmpty()const { return size==0; } void show()const { cout<<"["; for(int i=0;i<size;++i) { if(i!=0) cout<<','; cout<<elements[i]; } cout<<"]"; } //重载索引运算符[]，元素只读版本 int operator[](int index) const { if(index >=size || index < 0) //如果索引不合法 ，则抛异常 throw std::out_of_range(0); return elements[index]; } //重载索引运算符[]，元素可读可写版本 int& operator[](int index) { if(index >=size || index < 0) throw std::out_of_range(0); return elements[index]; } }; //end class int main() { ArrayList list1; list1.append(1); list1.append(2); list1.append(5); list1.insert(0,100); list1.remove(2); list1.show(); return 0; }
顺序表的短板
插入元素，时间复杂度 O(n)
插入为 第 i 个 元素，则需要移动 n - i +1 个数据元素. 需要移动 第 n 到第 i 个 元素。
均值的计算: 一共为 (n+1)(n+0) / 2 ，因为一共计算插了 n+1 个位置。则均值为 : n / 2
|
插为第 i 个 元素
|
1 | 2 | ... | n+1 |
| 移动 元素的个数 | n | n-1 | ... | 0 |
删除元素,时间复杂度 O(n)
删除 第 i 个 元素，则需要移动 n - i 个数据元素 。 需要移动 第 i+ 1 到 第 n 个 元素。
均值的计算:一共为 (n)(n-1+0) / 2 ，因为一共计算删除 n 个位置。则均值为 : (n-1) / 2
|
删除第 i 个 元素
|
1 | 2 | ... | n |
| 移动 元素的个数 | n-1 | n-2 | ... | 0 |
小提示
1、一般在实际开发时，为了尽量避免移动元素的开销，都会使用贴近硬件的API去完成内存数据的移动，而不是使用循环。例如使用memmove函数。
2、当内部数组的容量不够时，需要重新调整数组的大小，上面的例子我们使用了realloc函数去实现，且每次增加20。然而我们必须认识到，调整大小是很销耗资源的一个操作，因此在实际开发时，我们必须做出明智的容量增长策略。例如：Java中的ArrayList每次将容量扩展为原来的1.5倍。
| 编程语言中的实现类 | 增长因子 |
| Java ArrayList | 1.5 (3/2) |
| Python PyListObject | ~1.125 (n + n >> 3) |
| VC++ 2013 | 1.5 (3/2) |
| G++ 5.2.0 | 2 |
| Clang 3.6 | 2 |
编程练习
将2个非递减排序的顺序表合并为1个表，且新表也保持非递减排序。
如 [1,56,88 ] 和 [ 2,75] 合并后为 [ 1,2,56,75,88 ]
#include<iostream> #include<stdexcept> #include<cstdlib> using namespace std; class ArrayList { private: enum{ INCREMENT_SIZE = 20, //容量不足时，每次增加10个 INIT_CAPACITY = 10 //初始容量20 }; int size; //实际元素个数 int capacity; //容量 int* elements; //存储元素的数组的基地址 //确保表的容量至少为 reqCapacity 个。否则就增加容量 。 void ensureCapacity(int reqCapacity) { int* nelements; if(capacity<reqCapacity) { nelements = (int*)realloc(elements,(capacity+INCREMENT_SIZE)*sizeof(int)); if(nelements!=0) //如果对动态数组的大小调整成功 { elements = nelements; capacity+=INCREMENT_SIZE; } /* else{ //调整失败 exit(-1); } */ } } public: ArrayList():size(0),capacity(INIT_CAPACITY),elements(0) { elements = (int*)malloc(sizeof(int)*INIT_CAPACITY); } ~ArrayList() { free(elements); } /* * 功能:在表末尾追加元素 */ void append(int e) { ensureCapacity(size+1); elements[size++] = e; } /* * 将新元素e插入为索引为index * 合法的index值为 [0,size] ，当index为size时，不需要移动元素，当index为0时 * 需要移动所有元素。 * **/ bool insert(int index,int e) { if(index>size || index < 0) return false; //索引不合法 ensureCapacity(size+1); for(int i=size-1;i>=index;--i) { elements[i+1] = elements[i]; } elements[index] = e; size++; return true; } /* * 删除索引为index 的元素 。 * 合法的index值为 [0,size-1] ，当index=0时，删除的是第一个元素。 * 当index为size-1时，删除的是最后一个元素 **/ bool remove(int index) { if(index>=size || index <0) return false; //索引不合法 for(int i=index;i<size-1;++i) { elements[i] = elements[i+1]; } size --; return true; } /* * 功能：查找一个元素在表中的索引，如果不存在此元素，则返回-1 */ int indexOf(int e) const { for(int i=0;i<size;++i) { if(elements[i] == e) return i; } return -1; } /* * 功能:判断表中是否包含某个元素。 */ bool contains(int e) const { return (-1 != indexOf(e)); } int length() const { return size; } void clear() { size = 0; } bool isEmpty()const { return size==0; } void show()const { cout<<"["; for(int i=0;i<size;++i) { if(i!=0) cout<<','; cout<<elements[i]; } cout<<"]"; } //重载索引运算符[]，元素只读版本 int operator[](int index) const { if(index >=size || index < 0) //如果索引不合法 ，则抛异常 throw std::out_of_range(0); return elements[index]; } //重载索引运算符[]，元素可读可写版本 int& operator[](int index) { if(index >=size || index < 0) throw std::out_of_range(0); return elements[index]; } }; //end class /* * 功能：将2个非递减排序的顺序表合并为1个表re，且re表也保持非递减排序 */ void MergeList(const ArrayList& list1,const ArrayList& list2,ArrayList&re) { int i=0,j=0; //用于访问list1和list2的索引 int k=0; //访问re的索引 int e1,e2; //保存从list1和list2中提出的元素 while(i<list1.length() && j<list2.length()) { e1 = list1[i]; e2 = list2[j]; if(e1 <= e2) //比较大小，将小的元素加入到re表中。 { re.append(e1); i++; } else { re.append(e2); j++; } k++; } //如果list1还没访问完 while(i<list1.length()) { re.append( list1[i] ); i++; k++; } //如果list2还没访问完 while(j<list2.length()) { re.append( list2[j] ); j++; k++; } } int main() { ArrayList list1; ArrayList list2; ArrayList re; list1.append(12); list1.append(35); list1.append(88); list2.append(1); list2.append(2); list2.append(7); list2.append(82); list2.append(101); MergeList(list1,list2,re); re.show(); return 0; }
