数据结构与算法——顺序表

• 定义：一系列物理连续地址的存储单元，用来存储一系列的数据元素，一般是用数组的形式存储，（但和数组还是有一些区别），用来实现对数据的增删查改

（一）定义模板类

代码如下：

template  <class T>  			// 假定顺序表的元素类型为T
class arrList : public List<T>  {		// 顺序表，向量
private:    					// 线性表的取值类型和取值空间
	int  maxSize;            	// 私有变量，顺序表实例的最大长度
    int  curLen; 		    		// 私有变量，顺序表实例的当前长度
    int  position;				// 私有变量，当前处理位置
   	T  *aList ;            		// 私有变量，存储顺序表的实例
public: 						// 顺序表的运算集
	arrList(const int size) {  		// 创建一个新的顺序表，参数为表实例的最大长度
		maxSize = size;
		aList = new T[maxSize];
		curLen = position = 0;
	}
	~arrList() {					// 析构函数，用于消除该表实例
		delete [] aList;
	} 
	void clear() {      			// 将顺序表存储的内容清除，成为空表
		delete [] aList;
		curLen = position = 0;
		aList = new T[maxSize];
	}
	int length();            		// 返回此顺序表的当前实际长度
    bool append(T value);			// 在表尾添加一个元素value，表的长度增1
	bool insert(int p, T value);	 	// 在位置p上插入一个元素value，表的长度增1
	bool del(int p); 			// 删除位置p上的元素，表的长度减 1
	int getPos(const T value);		// 在线性表中查找值为value的元素，并返回第1次出现的位置
	void print();                     // 打印线性表 
}; 

（二）具体函数的实现：

构造函数：

arrlist(const int size){//创建一个新的顺序表，参数为表的最大长度
    maxsize=size;
    alist=new int[maxsize];
    curlen=position=0;
}

析构函数：

~arrlist(){
    delete[]alist;//析构函数，用于消除该表的实例
}

clear函数：

void clear(){//将顺序表储存的内容清除
    delete[]alist;
    curlen=position=0;
    alist=new int[maxsize];
}

length函数：

int length(){//返回此顺序表的当前实际长度
	return curlen;
}

getpos函数：

int getpos(const int value){//查找值为value的元素的下标
    for(int i=0;i<curlen;i++){
        if(value==alist[i])
            return i;
    }
    return -1;
}

insert函数：

bool insert(const int p,const int value){//在某位置插入元素
    if(curlen>=maxsize){
        cout<<"The List is overflow"<<endl;
        return false;
    }
    if(p<0||p>curlen){
        cout<<"Insertion point is illegal"<<endl;
        return false;
    }
    for (int i = curlen; i > p; i--) {
			alist[i] = alist[i - 1];
	}
	alist[p] = value;
	curlen++;
	return true;
}

del函数：

bool del(const int p){
    if(curlen==0){
        cout<<"No elements to delete"<<endl;
        return false;
    }
    if(p<0||p>curlen-1){
        cout<<"Deletion is illegal"<<endl;
        return false;
    }
    for(int i=p;i<=curlen-1;i++){
        alist[i]=alist[i+1];
    }
    curlen--;
    return true;
}

print函数：

void print(){
    for(int i=0;i<curlen;i++){
        cout<<alist[i];
    }
    cout<<endl;
}

（三）完整代码：

#include<iostream>
using namespace std;
class arrlist {
private:
	int* alist;//储存顺序表的实例
	int maxsize;//顺序表的最大长度
	int curlen;//顺序表的当前长度
	int position;//当前处理位置
public:
	arrlist(const int size) {//创建一个新的顺序表，参数为表的最大长度
		maxsize = size;
		alist = new int[maxsize];
		curlen = position = 0;
	}
	~arrlist() {
		delete[]alist;//析构函数，用于消除该表的实例
	}
	void clear() {//将顺序表储存的内容清除
		delete[]alist;
		curlen = position = 0;
		alist = new int[maxsize];
	}
	int length() {//返回此顺序表的当前实际长度
		return curlen;
	}
	int getpos(const int value) {//查找值为value的元素的下标
		for (int i = 0; i < maxsize; i++) {
			if (value == alist[i]) {
				return i;
			}
		}
		return -1;
	}
	bool insert(const int p, const int value) {//在某位置插入元素
		if (curlen >= maxsize) {
			cout << "The List is overflow" << endl;
			return false;
		}
		if (p<0 || p>curlen) {
			cout << "Insertion point is illegal" << endl;
			return false;
		}
		for (int i = curlen; i > p; i--) {
			alist[i] = alist[i - 1];
		}
		alist[p] = value;
		curlen++;
		return true;
	}
	bool del(const int p) {//删除顺序表上指定位置的元素
		if (curlen == 0) {
			cout << "No elements to delete" << endl;
			return false;
		}
		if (p<0 || p>curlen - 1) {
			cout << "deletion is illegal" << endl;
			return false;
		}
		for (int i = p; i <= curlen - 1; i++) {
			alist[i] = alist[i + 1];
			
		}
		curlen--;
			return true;
	}
	void print() {
		for (int i = 0; i < curlen; i++) {
			cout << alist[i];
		}
		cout << endl;
	}
};
int main() {
		arrlist a(10);
		a.insert(0, 1);
		a.print();
		a.insert(1, 3);
		a.insert(1, 2);
		a.print();
		a.insert(3, 4);
		cout<<a.length()<<endl;
		a.del(3);
		a.print();
		cout<<a.length()<<endl;
		cout << a.getpos(1);
		return 0;
}

（四）运行结果：

1
123
4
123
3
0

（五）关于时间复杂度：

• 按位置读取：$O(1)$

• 插入、删除、按内容查找：$O(n)$

• 查找：$$\sum _{i=1}^{n}p\times i=\frac{1}{n}(1+2+\cdots n)=\frac{n+1}{2}$$

• 插入：$$\sum _{i=0}^{n}p\times (n-i)=\frac{1}{n+1}\sum _{i=0}^n(n-i)=\frac{n}{2}$$