静态顺序表创建,初始化,插入,删除,查找

#include<stdlib.h>
#define MaxSize 20
typedef struct {
	int data[MaxSize];
	int length;
}sqlist;
//初始化顺序表
void inita(sqlist& L) {
	for (int i = 0; i < MaxSize; i++) {
		L.data[i] = 0;//初始化顺序表
	}
}
//往顺序表的第i个位置插入元素e
bool insertlist(sqlist& L, int i, int e) {
	if (i<1 || i>L.length + 1)//判断要插入的位置是否正确
		return false;
	if (L.length >= MaxSize) {//判断是否有空余的位置插入
		return false;
	}
		
	for (int j = L.length; j >= i; j--) {
		L.data[j - 1] = L.data[j];//第i个元素之后都往后移一个位置
		}
	L.data[i - 1] = e;
	L.length++;
	return true;
}
//删除顺序表第i个元素,并返回第一个元素位置
bool listdelete(sqlist& L, int i,int& e) {
	if (i<1 || i>L.length)//检查要删除的位置是否正确
		return false;
	e = L.data[i - 1];
	for (int j = i; j < L.length; j++) {
		L.data[j - 1] = L.data[j];//第i个元素之后都往前移动一个位置
	L.length--;
	return true;
	
	}
}
//按位查找
int getelem(sqlist& L, int i) {
	return L.data[i];
}
//按值查找
int locateElem(sqlist L, int e) {
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] = e) {
			return i + 1;
		}	
	}
}
int main() {
	sqlist L;
	inita(L);


	return 0;

}

以上就是各个模块的代码.下面我们来分析时间复杂度

//往顺序表的第i个位置插入元素e
bool insertlist(sqlist& L, int i, int e) {
	if (i<1 || i>L.length + 1)//判断要插入的位置是否正确
		return false;
	if (L.length >= MaxSize) {//判断是否有空余的位置插入
		return false;
	}
		
	for (int j = L.length; j >= i; j--) {
		L.data[j - 1] = L.data[j];//第i个元素之后都往后移一个位置
		}
	L.data[i - 1] = e;
	L.length++;
	return true;
}

在顺序表里插入一个元素:
最优:插在表尾 O(1)
最差:插在表头 O(n)
平均:有n个位置插入;分别为 1,2,…n那么时间复杂度位
(1+2+…+n)*1/n O(n)

//删除顺序表第i个元素,并返回第一个元素位置
bool listdelete(sqlist& L, int i,int& e) {
	if (i<1 || i>L.length)//检查要删除的位置是否正确
		return false;
	e = L.data[i - 1];
	for (int j = i; j < L.length; j++) {
		L.data[j - 1] = L.data[j];//第i个元素之后都往前移动一个位置
	L.length--;
	return true;
	
	}
}

在顺序表里删除指定位置元素:
最优:删除表尾 O(1)
最差:删除表头 O(n)
平均:有n个位置删除;分别为 1,2,…n那么时间复杂度位
(1+2+…+n)*1/n O(n)

/按位查找
int getelem(sqlist& L, int i) {
	return L.data[i];
}

按位查找
时间复杂度 O(1)
静态顺序表的优势之一.也是随机存储的体现

//按值查找
int locateElem(sqlist L, int e) {
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] = e) {
			return i + 1;
		}	
	}
}

按值查找
最优:在表头 O(1)
最差:在表位 O(n)
平均:有n个位置删除;分别为 1,2,…n那么时间复杂度位
(1+2+…+n)*1/n O(n)

ok抽空更新一下动态顺序表bye