数据结构——线性表总结

开学第六周了，数据结构第二章线性表也学完了，总结一下知识点吧。
　　这一章学习了线性表的逻辑结构、顺序存储结构及实现、链式存储结构及实现、顺序表和单链表的比较、线性表的其他存储方法、应用举例等。
线性表的定义： 零个或多个具有相同类型的数据元素的有限序列。
数据元素的个数定义为线性表的长度。长度等于0时称为空表。

线性表的顺序存储结构——顺序表

特点： 线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素。
作用： 线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。
顺序存储的实现： 一维数组存储顺序表中的数据。
顺序表支持数据元素的随机访问（利用下标进行访问）。

顺序表的代码实现（带模板）：
#include<bits/stdc++.h>
const int Maxsize=100;
template <class T>
class SeqList{ 
	T data[MaxSize]; // 存放数据元素 
	int length; // 线性表的长度 
public:
	SeqList (){length=0/*构造空表*/;}// 无参构造函数   
	SeqList (T a[],int n); // 有参构造函数 
	~SeqList(){} // 析构函数 
	int Length() {return length;} // 求线性表的长度
	T Get(int i); // 按位查找，取线性表的第 i 个元素 
	int Locate(T x); // 按值查找，求线性表中值为 x 的元素序号 
	void Insert (int i,T x); // 在线性表中第 i 个位置插入值为 x 的元素 
	T Delete(int i); // 删除线性表的第 i 个元素 
	void PrintList(); // 遍历线性表，按序号依次输出各元素 
};
//构造函数
template <class T> 
SeqList<T>::SeqList(T a[], int n){
	if (n>MaxSize) throw "参数非法";
	for (int i=0; i<n; i++) 
	data[i]=a[i];
	length=n;
}
//插入操作
template <class T> 
void SeqList<T>::Insert(int i, T x){ 
    int j;
    if (length>=MaxSize) throw "上溢";
    if (i<1 || i>length+1) throw "位置";
    for (j=length; j>=i; j--)
          data[j]=data[j-1];   
    data[i-1]=x;
    length++;
}
//删除操作
template <class T>
T SeqList<T>::Delete(int i){
	int j;
	T  x;
	if (length==0) throw "下溢";
	if (i<1 || i>length) throw "位置";
	x=data[i-1];
	for (j=i; j<length; j++)
		data[j-1]=data[j]; 
	length--;
	return x;
}
//按位置查找
template <class T> 
T SeqList<T>::Get(int i){
    if (i<1 && i>length) throw "查找位置非法";
    else return data[i-1];
}
//按置查找
template <class T>
int SeqList<T>::Locate(T x){
	for (int i=0; i<length; i++)
	if (data[i]==x) 
	return i+1 ;  //下标为i的元素等于x，返回其序号i+1
	return 0;  //退出循环，说明查找失败
}

顺序表示的优点:
(1) 无需为表示结点间的逻辑关系而增加额外的存储空间（因为逻辑上相邻的元素其存储的物理位置也是相邻的）；
(2) 可方便地随机存取表中的任一元素。
缺点：
(1)插入或删除运算不方便，
除表尾的位置外，在表的其它位置上进行插入或删除操作都必须移动大量的结点，其效率较低；
(2) 由于顺序表要求占用连续的存储空间，存储分配只能预先进行静态分配，因此当表长变化较大时，难以确定合适的存储规模。

线性表的链式存储结构——链式表

特点： 根据线性表的长度动态的申请存储空间，以解决顺序存储中存在的存储空间难以确定的问题。
链式存储结构的实现： 单链表、双向链表、循环链表等
头结点： 如果链表有头结点，则链式结构中的第一个节点称为头结点。其数据域可以存储一些附加信息，如链表长度；其指针域指向链表的第一个节点。

template <class T>
struct Node 
{ 
　　T data; 
　　Node<T> *next;
}; 
template <class T>
class LinkList { 
public: 
	LinkList ( ) {first=new Node<T>; first -> next= NULL ;}
	LinkList ( T a[ ], int n ) ; 
	~LinkList ( ) ; 
	int Length ( ) ;
	T Get ( int i ) ; 
	int Locate ( T x ) ;
	void Insert ( int i, T x ) ;
	T Delete ( int i ) ; 
	void PrintList ( ) ; 
private: 
	Node<T>  *first;
};
头插法：
Template<class T>
LinkList<T>::LinkList(T a[],int n){
	first=new Node<T>;
	first->next=NULL;
	Node<T> *s;
	for(int i=0;i<n;i++)
	{
		s=new Node<T>;
		s->data=a[i];
		s->next=first->next;
		first->next=s;
	}
}
尾插法：
template <class T>  
LinkList<T>:: LinkList(T a[], int n){
	Node<T> *r,*s;      //尾指针
	first=new Node<T>;   //生成头结点
	r=first;          
	for (int i=0; i<n; i++)
	{ 
		s=new Node<T>; 
		s->data=a[i];  //为每个数组元素建立一个结点
		r->next=s; r=s;      //插入到终端结点之后
	}
	r->next=NULL;    //单链表建立完毕，将终端结点的指针域置空
}
遍历：
template <class T>  
LinkList<T>:: PrintList()
{
	Node<T> *p;
	p=first->next;          
    while(p)
	{
		cout<<p->data;
        p=p->next;
	}
}
（
不带头结点的单链表构造：
头插法：
{
    first=NULL;
	for(int i=0;i<n;i++)
	{ 
         s=new node<T>;
         s->data=a[i];
         s->next=first;
         first=s;   
    }
}
尾插法：
node<T> *r;
head=NULL;
if（n<=0）return;
s=new node<T>;
s->data=a[0];
s->next=head;
head=s;   
r=head;
for(int i=1;i<n;i++)
{
	s=new node<T>;
    s->data=a[i];
    r->next=s;
    r=s;   
}
）
析构函数：
template <class T>
LinkList<T>:: ~LinkList()
{
   Node<T> *q;
   while (first)
   {
       q=first->next;
       delete first;
       first=q;
    }
}

循环链表

循环链表： 将单链表或者双链表的头尾结点链接起来，就是一个循环链表。

特点：首尾相接的链表。可以从任一节点出发，访问链表中的所有节点。
判断循环链表中尾结点的特点： q->next==first

循环链表的实现：
template <class T>
CycleLinkList<T>:: CycleLinkList()
{
         first=new Node<T>;
         first->next=first;
}
尾插：
template <class T>  
CycleLinkList<T>:: CycleLinkList(T a[], int n) {
	first=new Node<T>;   //生成头结点
	Node<T> *r,*s;
    r=first;          //尾指针初始化
    for (int i=0; i<n; i++)
    { 
        s=new Node<T>; 
        s->data=a[i];  
        r->next=s; 
        r=s;     
	}
    r->next=first;    //单链表建立完毕，将终端结点的指针域指向头结点
 }
头插：
template <class T>  
CycleLinkList<T>:: CycleLinkList(T a[], int n,int k)
 {
    first=new Node<T>;   //生成头结点
	first->next=first;
	Node<T> *s;
	for (int i=1; i<n; i++)
	{ 
      s=new Node<T>; 
	  s->data=a[i];  //为每个数组元素建立一个结点
      s->next=first->next;
	  first->next=s;
	}
}
将非循环的单链表改造成循环的单链表：
p=first;
while(p->next)
{ 
       p=p->next;  
 }
p->next=first;

双链表

双链表： 增加一个指向前驱的指针
双链表结点结构：



插入处理原则： 处理原则：先处理每个方向的 远端指针，再处理近端指针先在正向链表上插入，再在逆向链表上插入
插入：
q->rlink=p->rlink;
P->rlink=q;
q->llink=p;
if(q->rlink)
q->rlink->llink=q;
删除：
p->llink->rlink=p->rlink;
if(p->rlink)
p->rlink->llink=p->rlink;
delete( p);

双链表实现：
template <class T>
class DoubleLink {
private:
	Node<T> *head;
public:
	DoubleLink() ；
	~DoubleLink();
	void Append(T data);
	void Display();
	void Insert(int locate , T data);
	T Get(int locate);
	T Delete(int locate);
};
template <class T> 
DoubleLink <T>::DoubleLink(){
	head=new Node<T>;
	head->rlink=NULL;
	head->llink=NULL;
}
头插：
template <class T>
void DoubleLink<T>::Append(T data){
	Node<T> *s;
    s=new Node<T>;
	s->data=data;
	s->rlink=head->rlink;
	head->rlink=s;
	s->llink=head;
	if (s->rlink)
		s->rlink->llink=s;
	return;
}
遍历：
template <class T>
void DoubleLink<T>::Display(){
	Node <T> *p;
	p=head->rlink;
	while(p){
		cout<<p->data<<" ";
		p=p->rlink;
	}
	cout<<endl;
	return;
}
析构
template <class T>
DoubleLink<T>::~DoubleLink(){
	Node<T>  *p,*q;
	p=head;
	while(p)
	{
		q=p->rlink;
		delete p;
		p=q;
		
	}
}

链表的关键是指针的应用，一定要注意判断链表是否为空和指针越界等问题，越界修改起来特别困难。