先上代码,先上代码
#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)
下一期链表