线性表学习总结

一、线性表的定义

     是零个或多个具有相同类型的数据元素的有限序列。数据元素的个数定义为线性表的 长度 。长度等于零时称为空表，一个非空表通常记为 L ＝ ( a 1 ， a 2 ，……， a n )。其中， a i （ 1 ≤ i ≤ n ）称为数据元素，下标 i 表示该元素在线性表中的位置或序号， 称元素 a i 位于表的第 i 个位置，或称 a i 是表中的第 i 个元素。

二、线性表的顺序存储结构及其实现

特点：线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，

作用：线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

顺序存储的实现：一维数组存储顺序表中的数据

const int Maxsize=100;
template <class T>
class SeqList{ 
　private: 
　　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;  //退出循环，说明查找失败
}

三、线性表的链式存储结构及实现

链式存储分配的特点： 根据线性表的长度动态的申请存储空间，以解决顺序存储中存在的存储空间难以确定的问题。

（一）、单链表

//链表结点数据类型的定义
template <typename T>
struct Node 
{ 
　　T data; 
　　Node<T> *next;      //此处<T>也可以省略
}; 
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; // 单链表的头指针  , <T>可以省略
}; 
//头插法构造单链表
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;
	}
 }
//按位置查找
template <class T>
T LinkList<T>::Get(int i) {   
	  Node<T> *p; int j;
	  p=first->next;  j=1;  //或p=first;  j=0;
	  while (p && j<i) {
    		p=p->next;       //工作指针p后移
		j++;
  	 }
	  if (!p) throw "位置";
	  else return p->data;
}
//插入操作
template <class T>  
void LinkList<T>::Insert(int i, T x){  
   Node<T> *p; int j;
   p=first ; j=0;    //工作指针p初始化
   while (p && j<i-1)   {
     p=p->next;   //工作指针p后移
     j++;
   }
   if (!p) throw "位置";
    else { 
	  Node<T> *s;
      s=new Node<T>; 
	  s->data=x;  //向内存申请一个结点s，其数据域为x
      s->next=p->next;       //将结点s插入到结点p之后
      p->next=s;	
	}
 }
//删除操作
template <class T>  
T LinkList<T>::Delete(int i){ 
  Node<T> *p; int j;
  p=first ; j=0;  //工作指针p初始化
  while (p && j<i-1) {  //查找第i-1个结点
    p=p->next; 
    j++;
  }
  if (!p || !p->next) throw "位置";  //结点p不存在或结点p的后继结点不存在
    else {
  	     Node<T> *q; T x;
          q=p->next; x=q->data;  //暂存被删结点
          p->next=q->next;  //摘链
          delete q; 
          return x;
	}
}
//析构函数
template <class T>
LinkList<T>:: ~LinkList()
{
   Node<T> *q;
   while (first)
   {
       q=first->next;
       delete first;
       first=q;
    }
}

//不带头节点的单链表的构造
//头插法
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;   
}

（二）、循环链表

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

template <class T>
struct Node
{
   T data;
   Node<T> *next;
};
template <class T>
class CycleLinkList{
  public:
    CycleLinkList( ); 
    CycleLinkList(T a[ ], int n);  
    CycleLinkList(T a[ ], int n,int i);
    ~CycleLinkList();           
    int Length();        
    T Get(int i);          
     void Insert(int i, T x);
    T Delete(int i);        
    void PrintList( );    
 private:
   Node<T> *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;
	}
}

（三）、双链表

template <class T>
struct  DNode{
	T  data;
	DNode<T> *llink;
	 DNode <T>*rlink;
}; 
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;
		
	}
}