顺序表简介
特点：使用一组地址连续的存储单元依次存储表中的数据元素，常见的就是使用数组去实现。
表中逻辑相邻的数据元素，在物理内存上也相邻。
顺序表中的任意数据元素都可随机访问，是一种支持随机访问，长度自动动态调整的线性表结构。
优点：访问表中的元素很快，时间复杂度为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;
}
时间： 2024-12-14 18:06:58