【算法与数据结构 の 相关概念】线性表（顺序表,单链表,双链表）C++

顺序表

定义

顺序表 ：一个有序的数据元素的集合，对比数组我们会发现，它们同样是用一段物理地址连续的存储空间单元依次存储数据元素的线性结构，但数组是静态顺序表，在编译的时候，预分配了指定大小的内存单元，而顺序表可以通过初始化函数中的new或malloc分配动态的内存单元。

代码

template<typename Elemtype>
class SqList{
private:
	Elemtype* e;
	int size;
	int length;
public:
	SqList(int Max){
		e = new Elemtype[Max];
		length = 0;
		size = Max;
	}
	~SqList(){
		length = 0;
		size = 0;
		delete[]e;
		e = NULL;
	}
	bool SqList_Insert(int i,Elemtype elem){
		if(length == size) return false;
		if(i<1 || i>length+1) return false;
		if(i == length+1){
			e[length++] = elem;
			return true;
		}
		for(p=&e[i-1],q=&e[length-1];p<=q;q--){
		*(q+1)=*q;
		}
		*p = elem;
		length++;
		return true;
	}
	int SqList_FindElem(Elemtype elem){
		int i = 1;
		while(i != length){
			if(e[i-1]==elem) return i;
			i++;
		}
		if(i==length) return -1;
	}	
	bool SqList_Delete(int i,Elemtype& elem){
		if(i<1 || i>length) return false;
		for(j=length-1;j>i-1;j--){
			e[j-1]=e[j];
		}
		elem = e[i-1];
		length--;
		return true;
	}
}

单链表

定义

**单链表：**在每个存储结点中除包含数据域外，只设置一个指针域用以指向其直接后继结点，**优点：**相对于顺序表而言，插入删除操作需要平均需要移动半个表的元素，而链表每个结点的存储位置不连续，故插入删除操作更加方便省时，**缺点：**单链表当访问一个结点后，只能接着访问它的直接后继结点。

代码

#define nil elem_null	//define a elemtype varible with null value 
template <typename ElemType>
class LinkList{	
	struct LNode{
		ElemType data;	//data conservation
		LNode* next;	//point to next LNode
	};
private: 
	LNode* head;	
	LNode* p,q;
public:
	LinkList(){
		head = new LNode;
		head->next = NULL;
	}
	
	// initialize a LinkList without any data
	LinkList(int init_size){
		if(init_size<0) cout<<"error"<<endl;
		head = new LNode;
		head->next = NULL;
		p = head;
		while(p&&init_size--){
			q = new LNode;
			q->next = p->next;
			p->next = q;
			p = q;
		}
		p->next = NULL;
	}
	
	// initialize a LinkList with data originated from parameter datalink
	LinkList(int init_size,Elemtype* datalink){
		if(init_size<0) cout<<"error"<<endl;
		head = new LNode;
		head->next = NULL;
		p = head;
		for(int i=0; i<init_size; i++){
			q = new LNode;
			q->data = datalink[i];
			q->next = p->next;
			p->next = q;
			p = q;
		}
		p->next = NULL;
	}

	~LinkList(){
		while(head){
			p = head->next;
			delete head;
			head = p;
			}
	}
	bool LinkList_isEmpty(){
		if(!head) return true;
		else	return false;
	}
	
	// the linklist length preclude the head 
	int LinkList_Length(){
		int count = 0;
		p = head->next;
		while(p){
			count++;
			p = p->next;
		}
		return count;
	}
	
	
	Elemtype LinkList_GetElem(int i){
		if(i<1 ||i>LinkList_Length()) cout<<"error"<<endl;
  		p = head->next;
  		while(i--) p = p->next;
  		return p->data;
 	}
 
	int LinkList_FindElem(Elemtype e){
		int count = 0;
		p = head->next;
		while(p){
			count++;
			if(e == p->data) return count;
			p = p->next;
		}
		if(count == LinkList_length()) return -1;
	}
	int LinkList_Insert(int i,Elemtype e){
		if(i<1 ||i>LinkList_Length()) return -1;
		p = head;
		while((i-1)--) p = p->next;
		q = new LNode;
		q->data = e;
		q->next = p->next;
		p->next = q;
		return 0;
	}
	int LindkList_Delete(int i){
		if(i<1 ||i>LinkList_Length())	return -1;
		p = head;
		while((i-1)--) p = p->next;
		q = p->next;
		p->next = p->next->next;
		delete q;
	}
}

双向链表

定义

**双向链表：**它的每个结点中除了数据域外，都有两个指针，分别指向直接后继和直接前驱。**优点：**从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

代码

template<typename Elemtype>
class DualLinkList{
	struct LNode{
		Elemtype data;
		struct LNode* prior;
		struct LNode* next;
	}
	LNode* head,p,q;
	DualLinkList(){
		head = new LNode;
		head->prior = NULL;
		head->next = NULL;
	}
	DualLinkList(int init_size){
		if(init_size < 0) cout<<"error"<<endl;
		head = new LNode;
		head->prior = NULL;
		head->next = NULL;
		p = head;
		while(init_size--){
			q = new LNode;
			q->next = p->next;
			q->prior = p;
			p->next = q;
		}
	}
	DualLinkList(int init_size,Elemtype* e){
		if(init_size<0) cout<<"error"<<endl;
		head = new LNode;
		head->prior = NULL;
		head->next = NULL;
		p = head;
		for(int i=0;init_size !=0;init_size--){
			q = new LNode;
   			q->data = e[i++];
   			q->next = p->next;
   			q->prior = p;
   			p->next = q;
   		}
   	}
   	~DualLinkList(){
   		while(head){
   			p = head->next;
   			delete head;
   			head = p;
	}
	bool DualLinkList_isEmpty(){
		if(!head) return true;
		else return false;
	}
	int DualLinkList_Length(){
		p = head->next;
		int count = 0;
		while(p){
			count++;
			p = p->next;
		}
		return count;
	}
	Elemtype DualLinkList_GetElem(int i){
		if(i<1 || i>length) cout<<"error"<<endl;
		p = head;
		while(i--) p = p->next;
		return p->data;
	}
	int DualLinkList_FindElem(Elemtype e){
		p = head->next;
		int count;
		while(p){
			count++;
			if(e == p->data) return count;
			p = p->next;
		}
		if(count == DualLinkList_Length()) return -1;
	}
	bool DualLinkList_Insert(int i,Elemtype e){
		if(i<1 || i>DualLinkList_Length()) return false;
		p = head;
		while(i--) p = p->next;
		q = new LNode;
		q->prior = p->prior;
		q->prior->next = q;
		q->next = p;
		p->prior = q;
		return true;
	}
	bool DualLinkList_Delete(int i,Elemtype e){
		if(i<1 || i>DualLinkList_Length()) return false;
  		p = head;
  		while(i--) p = p->next;
  		p->prior->next = p->next;
  		p->next->prior = p->prior;
  		delete p;
  		p = NULL;
  		return true;
  	}
}