线性表的两种实现

昨晚数据结构最简单也是最基础的线性表，有两种实现方式：

1、是逻辑结构与物理结构一致的顺序表，具体来说，就是用数组来实现

2、是数据的逻辑次序与物理次序很有可能不一致的链式表，通过结点来存储后继点的指针地址

顺序表定义：

const int MAX=100;
template<typename T>
class seqlist{
private:
  T data[MAX];
  int size;
public:
	seqlist(){size=0;}
	seqlist(T a[],int n){
	if(n>MAX)throw "n error";
	for(int i=0;i<n;i++)
	data[i]=a[i];
	size=n;}
	~seqlist(){}
	int getsize(){return size;}
    T get(int i);
    int loc(T x);
void insert(int i,T x);
T dele(int i);
void prt();};
template<typename T>
T seqlist<T>::get(int i){
if(i>size||i<1)throw"i error";
return data[i-1];}
template<typename T>
int seqlist<T>::loc(T x){
for(int i=0;i<size;i++)
  if(data[i]==x) return i+1;
return -1;}
template<typename T>
void seqlist<T>::insert(int i,T x){
if(size>=MAX)throw"overflow";
if(i>size+1||i<1)throw"i error";
for(int j=size;j>=i;j--)
  data[j]=data[j-1];
data[i-1]=x;
size++;}
template<typename T>
T seqlist<T>::dele(int i){
if(size<1)throw"downflow";
if(i<1||i>size)throw"i error";
T x=data[i-1];
for(int j=i;j<size;j++)
  data[j-1]=data[j];
size--;
return x;
}
template<typename T>
void seqlist<T>::prt(){
if(size<1)cout<<"empty"<<endl;
else {
for(int i=0;i<size;i++)
  cout<<data[i]<<" ";
cout<<endl;}}

链式表(以结点只含一个指针的单链表为例)：

//link list
template<typename T>
struct node{
 T data;
 node<T>*next;};
 template<typename T>
 class linklist{
 private:node<T>*first;//单链表的头指针
		 int linksize;
 public:
	 linklist(){fisrt=new node<T>;
	 first->next=NULL;//无参构造构造空线性表
	 linksize=0;}
	 linklist(T a[],int n){
	 first=new node<T>;
	 first->next=NULL;//先构造空链表
	 linksize=n;
	 node<T>*p=first;
	 for(int i=0;i<n;i++)
	 {node<T>*s=new node<T>;
	 s->data=a[i];
	 s->next=p->next;//插入到头节点之后
	 p->next=s;}}
	 ~linklist(){
	 node<T>*p=first;
	 while(p){
	 node<T>*q=p;
	 p=p->next;
	 delete q;}}
     int size();
 T get(int i);
 int loc(T x);
 void insert(int i,T x);
 T del(int i);
 void prt();};
 template<typename T>
 int linklist<T>::size(){
 return  linksize;}
 template<typename T>
 T linklist<T>::get(int i){
 node<T>*p=first;
 int j=0;
 while(p&&j<i){
 p=p->next;
 j++;}
 if(!p) throw"i error";
 else return p->data;}
 template<typename T>
 int linklist<T>::loc(T x){
 node<T>*p=first;
 int j=0;
 while(p&&x!=p->data){
	 p=p->next;
 j++;}
 if(!p)throw"x no";
 else return j;}
 template<typename T>
 void linklist<T>::insert(int i,T x){
 node<T>*p=first;
 int j=0;
 while(p&&j<i-1){
	 p=p->next;
 j++;}//找到i-1
 if(!p)throw"insert error";
 else{
 node<T>*s=new node<T>;
 s->data=x;
 s->next=p->next;
 p->next=s;}
 linksize++;}
 template<typename T>
 T linklist<T>::del(int i){
 node<T>*p=first;
 int j=0;
 while(p&&j<i-1){
	 p=p->next;
 j++;}
 if(!p||!p->next)throw"del error";
 else{
	 T t=p->next->data;
	 p->next=p->next->next;
 return t;}
 linksize--;}
 template<typename T>
 void linklist<T>::prt(){
 node<T>*p=first;
 if(!p)cout<<"empty"<<endl;
  p=p->next;
 while(p){
	 cout<<p->data<<" ";
	 p=p->next;}
 cout<<endl;}

两者的调用类似，因为只是内部实现不一样，其接口还是不变。这体现了数据结构的封装性：

#include"2.h"
int main(){
int a[]={10,12,15,25,8,16,20};
seqlist<int>li(a,7);
linklist<int>l(a,7);
cout<<"the inf li:"<<endl;
li.prt();
cout<<"the inf of linklist:"<<endl;
l.prt();
try{
cout<<"the size of seqlist:"<<endl;
cout<<li.getsize()<<endl;
cout<<"the size of linksize:"<<endl;
cout<<l.size()<<endl;
cout<<"find the ith:"<<endl;
cout<<li.get(3)<<endl;
cout<<"find the ith:"<<endl;
cout<<l.get(3)<<endl;
cout<<"the loc of 15"<<endl;
cout<<li.loc(15)<<endl;
cout<<"the loc of 15:"<<endl;
cout<<l.loc(15)<<endl;
li.insert(3,100);
cout<<"the new after insert:"<<endl;
li.prt();
l.insert(3,100);
cout<<"the new after insert:"<<endl;
l.prt();
li.dele(3);
cout<<"the new after dele:"<<endl;
li.prt();
l.del(3);
cout<<"the new after dele:"<<endl;
l.prt();}
catch(string&s){
cout<<s<<endl;
}
system("pause");
return 0;}

两者的比较：

一、时间性能比较：

是指基于某种存储结构的算法时间复杂度。类如取出线性表内任意某个元素，使用顺序表快一点时间性能O(1)，而链式表只能从表头开始依次向后扫描直至特定位置O(n)；但是在进行相应插入与删除操作时候，在给出该处指针以后，增删所需时间O(1)，而顺序表需平均移动一半元素，时间性能O(n)，这对于大规模线性表来说，是不可忍受的。

二、空间性能比较：

首先定义存储密度：存储密度=（数据域占用的存储量）/（整个节点占用的存储量）

顺序表存储密度为1，而链式表数据域和指针域各占一部分节点，从这一层来说，顺序表更好；但是顺序表需要预先静态分配一定长度的存储空间，如果事先不知道线性表规模，会面临预分配过剩导致的浪费或者预分配过少导致的碎片，而单链表无需预分配。根据需要动态产生即可。故当线性表规模小或者规模已知时候用顺序表，否则用单链表。