动态顺序表的创建,增加,删除,查找

先上代码,先上代码

#include<stdio.h>
#include<stdlib.h>
#define initsize 10
typedef  struct {
	int* data;//用动态指针存储数据
	int maxsize;
	int length;
}seqlist;
//初始动态顺序表
void intiseqlist(seqlist& l) {
	l.data = (int*)(malloc(sizeof(int ) * initsize));
	l.length = 0;
	l.maxsize = initsize;
}
//为动态顺序表申请动态存储空间
void increasesize(seqlist& l, int len) {
	int* p = l.data;
	l.data = (int*)malloc(sizeof(int) * (len + initsize));//malloc申请空间之后强转为l.data对应的类型
	for (int i = 0; i < l.length; i++) {
		l.data[i] = p[i];
	}
	l.maxsize = l.maxsize + len;
	free(p);//释放
}
//在顺序表内第i个位置添加元素e
bool inserlist(seqlist& l, int i, int e) {
	if (i<1 || i>l.length + 1)
		return false;
	if (l.length > l.maxsize)
		return false;
	if (l.length = l.maxsize) {

		increasesize(l, 1);//和静态顺序表唯一有	区别的地方,在在表位刚好没空间时候,可以申请一个空间
		l.data[l.length] = e;
		return true;
	}
	for (int j = l.length; j >= i; j--) {
		l.data[j] = l.data[j - 1];	
	}
	l.data[i - 1] = e;
	l.length++;
	return true;
}
//动态顺序表的删除
bool  deletele(seqlist& 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];
	
	}
	l.length--;
	return true;
}
//按位查找
int getelemseq(seqlist& L, int i) {
	return L.data[i];
}
//按值查找
int locateElemseq(seqlist L, int e) {
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] = e) {
			return i + 1;
		}
	}
}
int main() {
	seqlist l;
	intiseqlist(l);
	increasesize(l, 2);

	return 0;
}

简单说一下动态顺序表的一些特殊.简单说一下三个变量.initsize,maxsize,length.
其中initsize就是初始化顺序表的容量,第一次初始化顺序表的时候,initsize=maxsize
maxsize代表这个顺序表能容纳多少数据
length代表目前顺序表有多少数据.
需要区分的是maxsize和length;如果让我们便利顺序表,i<length,而不是maxsize.
下面我们分析时间复杂度

//在顺序表内第i个位置添加元素e
bool inserlist(seqlist& l, int i, int e) {
	if (i<1 || i>l.length + 1)
		return false;
	if (l.length > l.maxsize)
		return false;
	if (l.length = l.maxsize) {

		increasesize(l, 1);//和静态顺序表唯一有	区别的地方,在在表位刚好没空间时候,可以申请一个空间
		l.data[l.length] = e;
		return true;
	}
	for (int j = l.length; j >= i; j--) {
		l.data[j] = l.data[j - 1];	
	}
	l.data[i - 1] = e;
	l.length++;
	return true;
}

在顺序表里插入一个元素:
最优:插在表尾 O(1)
最差:插在表头 O(n)
平均:有n=1个位置插入;分别为 1,2,…n那么时间复杂度位
(1+2+…+n)*1/(n+1) O(n)
在平均复杂度这里稍微有一点小区别,就是当空间满的时候,在表位插入,我们可与动态增加一个存储空间.有(1+n)个位置

//动态顺序表的删除
bool  deletele(seqlist& 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];
	
	}
	l.length--;
	return true;
}

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

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

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

//按值查找
int locateElemseq(seqlist 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)

下一期链表