2.2 顺序表

顺序表

目录

• 顺序表
  • 定义
  • 静态顺序表
    • 定义
    • 基本操作及时间复杂度
      • 1、初始化
      • 2、插入
      • 3、删除
      • 4、按位查找
      • 5、按值查找
  • 动态顺序表
    • 定义
    • 基本操作
      • 1、初始化
      • 2、增加数组长度
      • 3、插入
      • 4、删除
      • 5、查找

定义

​ 用顺序存储的方式实现线性表的顺序存储。把逻辑上相邻的元素存储在物理位置也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。

​ 顺序表这种物理位置相邻的数据结构是基于数组实现的。数据结构作用的数据元素是数组中的元素，而数组是数据对象，故而对顺序表的操作，即是对单个数组进行操作。这也是与其他线性表不同的一个方面。

​ 按顺序表的长度是否可变，分为静态顺序表和动态顺序表。

静态顺序表

定义

​ 内存空间始终固定不变的顺序表。

下面的代码中类似 int &n 的代码; 的的语句属于 C++, C语言不能编译。
含义为：声明 n 为一个 int 类型的引用 。
如函数调用中将 实参 a 传给 n, 表示 n 为 a 的引用，或者说 a 的别名，在函数中将直接操作 a 中的内容。

#define MAXSIZE 10		// 顺序表最大长度
typedef struct {		// 定义顺序表元素结构，并设置别名
	int data[MAXSIZE] 	// 用静态数组来存放数据元素
	int length;			// 顺序表当前长度
} SeqList; 				// Sequence：顺序

基本操作及时间复杂度

1、初始化

​ 初始化要遍历整个数组，循环次数为数组长度n，故时间复杂度为 O(n)。

// 1、初始化 
void InitSeqList(SeqList &L){
	// 随机分配的内存空间都存在垃圾数据，清空所有垃圾数据。
	for(int i=0; i<MAXSIZE; i++){
		L.data[i] = 0;
	} 
	// length中也存有垃圾值，只有static全局变量分配到的内存才会是 0 
	L.length = 0;	// 顺序表的长度初始为 0; 
} 

2、插入

​ 插入数据时要将后面的元素都向后移，最坏情况下要将数组所有元素向后移，循环次数为数组的长度n，故时间复杂度为 O(n)。

// 2、插入元素
bool ListInsert(SeqList &L, int i, int data){
    // 检查位序i 是否正确。位序从1开始。
    if (i<1 || i > L.length+1) return false;
    // 检查数组是否装满
    if (L.length >= MAXSIZE) return false;
    
    // 将位序i上的元素及其后面的元素后移。数组下标从0开始，比位序小1。
    for (int j=L.length; j>=i; j--){
        L.data[j] = L.data[j-1];
    }
    
    // 在位序为 i 处插入元素, 表尾指针后移。
    L.data[i-1] = data;
    L.length ++;
    
    return true;
}

3、删除

​ 删除元素需要将后面的元素向前移。最坏的情况下需要移动数组中除第一个元素外的所有元素，循环次数为 n-1，时间复杂度为 O(n)

// 3、删除元素; 删除 i 处的
bool ListDelete(SeqList &L, int i, int &e){
    // 检查位序i 是否正确
    if (i<1 || i > L.length) return false;
    
    // 将位序i 上的元素通过 e 传递出去。
    e = L.data[i-1];
    
    // 向前移动位序i后面的元素
    for( ; i<L.length; i++){
        L.data[i-1] = L.data[i];
    }
    
    // 表尾指针前移
    L.length--;
    
    return true;
}

4、按位查找

​ 由于顺序表的各个数据元素在内存中连续存放，因此可以根据起始地址和数据元素大小立即找到第 i 个元素——“随机存取”特性。

​ 时间复杂度为 O(1)。

// 4、按位查找
int ListLocated(SeqList &L, int i){
    // 检查位序i 是否正确
    if (i<1 || i > L.length) return 0;
    // 返回位序为 i 的元素。
    return L.data[i-1];
}

5、按值查找

​ 按值查找需要对比每个元素，无法提前知道元素的位置，故而需要遍历整个数组。最坏情况下，遍历完数组所有元素，循环执行n次，时间复杂度为 O(n)。

// 5、按值查找
int ListFind(SeqList &L, int e){
    // 按顺序遍历所有元素
    for(int i=0; i<L.length; i++){
        if (L.data[i] == e)         // 找到元素，返回位序
            return i+1;     
    }
    return 0;   // 遍历完所有元素仍未找到，返回0，而位序从1开始。
}

动态顺序表

定义

顺序表满了以后，如果再插入数据，就重新开辟一个更大的空间。

// 动态顺序表 
#define InitSize 10 	// 顺序表的初始长度
typedef struct{
	int *data; 			// 指示动态分配数组的指针
	int MaxSize; 		// 顺序表的最大容量
	int length; 		// 顺序表的当前长度
} DySeqList;			// dynamic: 动态的 

基本操作

动态顺序表的初始化、与插入操作与静态顺序表稍有不同，且多一个增加数组长度的操作。其他操作均与静态数组一致。

1、初始化

数据初始化需要遍历整个数组，时间复杂度为 O(n)。

// 1、初始化
void InitSeqList(DySeqList &L){
	// malloc 动态申请一块连续的内存空间 
	L.data = (int *)malloc(InitSize*sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
	// 动态分配的内存中也都是垃圾值，需要清空 
	for(int i=0; i<L.MaxSize; i++){
		L.data[i] = 0;
	}
}

2、增加数组长度

​ 复制数据和清理数组需要遍历整个数组，时间复杂度为 O(n)。

// 2、增加动态数组的长度 
void IncreaseSize(DySeqList &DL, int len){
    // n 增加的长度
    int *p = DL.data;
    DL.MaxSize += len;
    // 重新申请空间 
    DL.data = (int*)malloc(DL.MaxSize*sizeof(int));
    
    // 复制数据 
    int i = 0;
    for ( ; i<DL.length; i++){
        DL.data[i] = p[i];
    }
    
    // 清除垃圾数据
	for ( ; i<DL.MaxSize; i++){
        DL.data[i] = 0;
    }
    
    // 释放旧内存
    free(p);
}

3、插入

​ 插入数据与静态顺序表不同，动态数组满了后可以增加数组长度，而不是返回 false。

​ 最坏情况下，需要先增加数组长度，再插入元素, 时间复杂度都为 O(n)，和仍然为 O(n)。

​ 时间复杂度为 O(n)。

// 3、插入元素
bool ListInsert(DySeqList &L, int i, int data){
    // 检查位序i 是否正确。位序从1开始。
    if (i<1 || i > L.length+1) return false;
    // 检查数组是否装满
    if (L.length >= MAXSIZE) 
        IncreaseSize(L, InitSize);
    
    // 将位序i上的元素及其后面的元素后移。数组下标从0开始，比位序小1。
    for (int j=L.length; j>=i; j--){
        L.data[j] = L.data[j-1];
    }
    
    // 在位序为 i 处插入元素, 表尾指针后移。
    L.data[i-1] = data;
    L.length ++;
    
    return true;
}

4、删除

​ 算法完全同静态顺序表，时间复杂度为 O(n)。

// 4、删除元素; 删除 i 处的
bool ListDelete(DySeqList &L, int i, int &e){
    // 检查位序i 是否正确
    if (i<1 || i > L.length) return false;
    
    // 将位序i 上的元素通过 e 传递出去。
    e = L.data[i-1];
    
    // 向前移动位序i后面的元素
    for( ; i<L.length; i++){
        L.data[i-1] = L.data[i];
    }
    
    // 表尾指针前移
    L.length--;
    
    return true;
}

5、查找

查找算法完全同静态顺序表，按位查找、按值查找的时间复杂度分别为 O(1)、O(n)。

// 5、按位查找
int ListLocated(DySeqList &L, int i){
    // 检查位序i 是否正确
    if (i<1 || i > L.length) return 0;
    // 返回位序为 i 的元素。
    return L.data[i-1];
}

// 6、按值查找
int ListFind(DySeqList &L, int e){
    // 按顺序遍历所有元素
    for(int i=0; i<L.length; i++){
        if (L.data[i] == e)         // 找到元素，返回位序
            return i+1;
    }
    return 0;   // 遍历完所有元素仍未找到，返回0，而位序从1开始。
}