本文介绍了线性顺序表的概念，包括其定义、存储结构和操作。线性顺序表是一种利用顺序结构存储线性表数据元素的数据结构。文章详细分析了线性顺序表的索引、查找、插入、删除和合并操作的时间复杂度，其中查找和插入的时间复杂度为O(n)，合并的时间复杂度最优为O(n+m)。
定义
线性顺序表是线性表中一种利用顺序结构实现的数据结构。线性顺序表又被称为线性表的顺序映射或者线性表的顺序存储结构。
它指的是利用一组地址连续的存储单元依次存储线性表的数据元素。
就如上图所示，线性顺序表的元素之间是连续的。假设线性顺序表的每个元素需要占用d个存储单元，并且规定线性顺序表
第一个存储单元的地址为基地址（首地址）。那么线性顺序表中第i+1个元素的地址和第i个元素的地址有一下关系
对以上公式进行整理，那么可以得出线性顺序表中第i个元素ai的存储位置为
例如：线性顺序表A有存储了5个元素，分别为apple, banana, orange, strawberry, melon; 每个元素所占内存空间为d。
假设A的基地址为loc_base, 也就是a元素存储的地址，也是A1的地址。对应的地址单元存储了apple。那么A2的地址
就是loc_base + d, 对应的地址单元存储了banana。A3的地址就是loc_base + 2d，对应的地址单元存储了orange.
相关操作以及时间复杂度分析
索引（Index）
对于线性顺序表来说，它是随机存取的，任何一个元素只要知道它在线性顺序表的逻辑下标，就可以索引对应在物理地址中存储的元素。
例如：获取线性顺序表A中的第5个元素的值，那么可以通过A5直接索引获取。因此这个操作的时间复杂度为O（1）。
查找（Find）
查找和索引不同点就是索引是根据下标找元素，一定能找到对应的值。而查找是根据给定的值定位在线性表中的位置。
如果线性表中无对应的值一般返回-1或者false。现在表A中存储了n个元素，需要查找元素t在表A中的位置。如果线性顺序表中的元素
是可比较，并且已经排好序的我们可以用二分查找，时间复杂度为O(logn)。但是这是一个一般的表，所以我们只能通过
遍历来查找。因此假设元素t在A中第i个元素被查找到的概率为pi。那么查找对应的数学期望值如下：
现在假设pi都具有相同的概率1/n; 那么对上述表达式进行化简得到如下结果：
再将如上级数进行整理可得
因此查找的时间复杂度为O（n）。
插入（Insert）
插入操作对于线性表来说应该是由两个步骤组成。一，定位插入点将插入点之后的元素往后移动。二，插入元素。
而这两个步骤对时间复杂度起决定性因素的是步骤一。因为步骤二的时间复杂度显然是O（1）。现在，对步骤一进行
时间复杂度的分析。假设表A中存储了n个元素，现在要把元素t插入到A表中的第i个元素之前。那么我需要将第i,i+1,i+2,……,n个
元素都往后移动一个位置。对于这个移动步骤的需要消耗的时间是O(n-i+1)。假设插入到第i个元素之前的概率为pi。
则插入的数学期望值如下：
这里为什么是n+1，因为元素有n个，那么插入的位置就有n+1个。现在假设每个插入的位置的概率pi都是1/（n+1）;
化简整理上述表达式得到如下结果：
再将如上级数化简进行整理可得
因此插入的时间复杂度为O（n）。
删除（Delete）
删除操作和插入操作正好相反，它也有两个步骤。一，删除元素。二，将后面的元素往前移动一个位置。这两个步骤对时间复杂度
起决定性因素的是步骤二。因为步骤一的时间复杂度显然是O（1）。（当然如果不是通过下标删除，而是通过给定元素删除的话
就是花费查找的时间O（n）, 这里我们只讨论是通过下标删除）现在对步骤二进行分析。假设表A中存储了n个元素，现在要删除A表中的第i个元素，
则第i+1, i+2, ……, n个元素都要往前移动一个位置。对于这个移动步骤的需要消耗的时间是O(n-i)。假设删除第i个元素的概率为pi。
则删除的数学期望值如下：
现在假设pi都具有相同的概率1/n; 那么对上述表达式进行化简得到如下结果：
再将如上级数化简进行整理可得
合并（Merge）
将两个有序的线性表合并是很常见的操作。例如非递减序列La = {1, 3, 4, 4, 7 , 10} 和 Lb = {2, 2, 8, 9}
进行合并的结果为Lc = {1, 2, 2, 3, 4, 4, 7, 8, 9, 10}。关于合并这里有两种算法：
算法一：
从Lb 中逐个取出元素与La中的元素相比，插入到合适位置。例如第一次，从Lb取出2，分别与La
中的1相比，发现比1大，继续往后比较。与3比较，发现比3小，那么2就插入到3前面。现在La = {1, 2, 3, 4, 4, 7, 10}; 第二次，从Lb取出第二个2，分别与La中的1比较，发现比1小，往后与2比较，发现和它一样， 再往后与3比较，发现比3小
那么插入到3前面。现在La = {1, 2, 2, 3, 4, 4, 7, 10}; 以此类推，直到Lb中所有元素插入到La中，就完成了合并假设La的元素个数为n，Lb的元素个数为m，那么该算法的时间复杂度明显是O（n*m）;
算法二：
对于La和Lb都是已经排好序的非递减序列。那么对于Lb中Lbj
和Lbj+1满足如下约束条件：如果Lai ≤ Lbj，那么Lai ≤ Lbj+1;
因此算法一是可优化的。因为算法一中有大量不必要的比较步骤，当Lbj已经确定了插入位置，Lbj+1
只需要和Lbj之后的元素相比较就可以，不需要重新从La表中的第一个元素开始比较。于是就有了如下算法，
用一个p指针指向La的第一个元素，q指针指向Lb中的第一个元素。并且申请一个新的线性顺序表Lc用来存储合并结果
并且用r指针指向Lc的第一个元素。规定n,m分别为La的元素个数和Lb表的元素个数，重复如下步骤直到p > n 或者 q > m:步骤：比较p指向的元素和q指向的元素，如果p指向的元素较小，则将其放入Lc表中，p++， r++；反之 q指向的元素放入Lc表 q++, r++;
重复完成退出后，将La或Lb表中剩下的元素移入Lc表。这样就完成了合并。
这个算法的时间复杂度明显是O（n+m）；
实现代码
#include<stdio.h>
#include<stdlib.h>
#define INIT_SIZE 10 // 线性表初始容量
#define INCREMENT_SIZE 5 // 当线性表容量不够时，增加元素之前，线性表增长量
#define OVERFLOW -5 // 内存分配失败后的退出代号
typedef struct {
int *data; // 线性顺序表的基地址（首地址）ַ
int length; // 当前线性表元素个数
int capacity; //当前线性表的容量
} SequenceList;
/*
* 初始化线性表分配内存空间以及相关参数设定
*/
void init_list(SequenceList *slist)
{
// 因为这里存的是int类型数据，则线性表的内存空间为 容量*int类型字节数
// 将内存空间的基地址给slist->data
slist->data = (int *)malloc(INIT_SIZE*sizeof(int));
if(!slist->data) exit(OVERFLOW); // 如果分配内存失败则退出程序
slist->length = 0; //初始化当前元素个数为0
slist->capacity = INIT_SIZE; // 初始化当前线性表容量为INIT_SIZE
}
/*
* 插入操作
*/
void insert(SequenceList *slist, int element, int index)
{
// 插入之前判断线性表的容量是否够大，如果不够，按照INCREMENT_SIZE扩充容量
// 重新申请内存空间
if(index >= slist->capacity)
{
slist->data = (int *)realloc(slist->data,
(slist->capacity + INCREMENT_SIZE)*sizeof(int));
if(!slist->data) exit(OVERFLOW);
slist->capacity += INCREMENT_SIZE;
}
for(int i=slist->length-1; i > index ; i--)
*(slist->data + i + 1) = *(slist->data + i);
*(slist->data + index) = element;
slist->length++;
}
/*
* 索引操作
*/
int getElement(SequenceList *slist, int index)
{
return *(slist->data + index);
}
/*
* 更新操作
*/
void updateElement(SequenceList *slist, int index, int newValue)
{
*(slist->data + index) = newValue;
}
/*
* 删除操作
*/
int deleteElement(SequenceList *slist, int index)
{
int result = *(slist->data + index);
for(int i=index; i < slist->length; i++)
*(slist->data + i) = *(slist->data + i + 1);
slist->length--;
return result;
}
/*
* 合并操作
*/
SequenceList mergeList(SequenceList slist1, SequenceList slist2)
{
SequenceList newList;
init_list(&newList);
int p = 0;
int q = 0;
int r = 0;
while(p<slist1.length && q<slist2.length){
int a = *(slist1.data+p);
int b = *(slist2.data+q);
printf("compare a = %d, b = %d\n", a, b);
if (a <= b){
insert(&newList, a, r);
p++;
}else {
insert(&newList, b, r);
q++;
}
r++;
}
while(p < slist1.length) {
insert(&newList, *(slist1.data + p), r);
r++;
p++;
}
while(q < slist2.length) {
insert(&newList, *(slist2.data + q), r);
r++;
q++;
}
return newList;
}
/*
* 打印线性顺序表的所有信息
*/
void print_slist_info(SequenceList slist)
{
printf("sequence list\ncapacity is %d\nlength is %d\n", slist.capacity, slist.length);
for(int i=0; i < slist.length; i++)
printf("%d ", *(slist.data + i));
}
int main()
{
// 以下都是增删改查测试
SequenceList sequence_list;
init_list(&sequence_list);
insert(&sequence_list, 10, 0);
insert(&sequence_list, 8, 1);
insert(&sequence_list, 7, 2);
insert(&sequence_list, 4, 3);
insert(&sequence_list, 9, 4);
insert(&sequence_list, 15, 2);
print_slist_info(sequence_list);
deleteElement(&sequence_list, 2);
print_slist_info(sequence_list);
printf("get element by %d is %d", 3, getElement(&sequence_list, 3));
updateElement(&sequence_list, 3, 100);
print_slist_info(sequence_list);
// 合并操作测试
SequenceList orderList1;
init_list(&orderList1);
insert(&orderList1, 1, 0);
insert(&orderList1, 2, 1);
insert(&orderList1, 3, 2);
insert(&orderList1, 4, 3);
SequenceList orderList2;
init_list(&orderList2);
insert(&orderList2, 5, 0);
insert(&orderList2, 6, 1);
insert(&orderList2, 7, 2);
insert(&orderList2, 8, 3);
SequenceList resultList = mergeList(orderList1, orderList2);
print_slist_info(resultList);
return 0;
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
