数据结构-线性表的连接存储结构及实现

之前我学到了顺序表，但是，顺序表还是存在着一定的缺陷例如：
（1）插入或删除运算不方便。
除表尾的位置外，在表的其他位置上进行插入或删除操作必须移动大量结点，其效率较低；
（2）由于顺序表要求占用连续的存储空间，存储分配只能预先进行静态分配，因此当表长变化较大时，很难确定适合的存储规模。
因此线性表的链式存储结构就可以解决顺序存储的存储空间难以确定的问题。

1.链式存储结构的实现有：

1. 单链表
2. 双向链表
3. 循环列表等

通过指针把它的一串存储结点链接成一个链；（如下图）
存储结点有两部分组成。
（1）数据
（2）指针

单链表结点之间可以连续，也可以不连续存储；
结点的逻辑顺序与物理顺序可以不一致。
因此可以充分利用系统中的内存。

2.链表结点数据类型的定义

C++中可以利用结构体来描述单链表的结点，由于结点的元素类型不确定，所以采用模板机制；

template <typename T>
struck Node
{
	T data;
	Node <T>*next;//指针记录下一结点的地址。
};//结构体后不要忘了；

数据定义完了，接着是最简单的带头结点的链表，我认为头节点也就是第一个结点。其目的是将地址指向链表的第一个结点。

3.单链表的实现

首先是单链表类的定义部分，其中有些简单的函数可以在类中直接给出
比如构造一个空的链表可以将头节点的next指针置空，再者是析构函数，系统自动生成，所以无需定义。

template<class T>
class LinkList
{
private:
		Node<T>*first;//生成单链表的头指针<T>可以省略
public:
		LinkList(){first=new Node<T>;first->next=NULL;}
		LinkList(T a[],int n);
		~LinkList;
		int Length();//求单链表的长度
		T Get(int i);//按位查找，查找第i个结点元素的值
		int Locate(T x);//按值查找
		void Insert(int i,T x);//插入操作，在第i个位置插入值为x的结点
		T Delete(int i);//删除操作删除第i个结点
		void PrintList();//遍历操作，输出所有元素
		
}

4.链表的构造-头插法：

• 头插法特点：头节点一般存储首个结点的地址，插入的结点链接在头节点之后，插入后的结点作为首个结点。
• 其插入步骤如下：

• 其有参构造函数如下：

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;
		}
}

• 单链表构造-尾插法

与头插法不同，尾插法是将新建的结点插入到结点最后。然而，头节点只是指向第一个结点，因此需要建立一个尾结点来存储尾结点地址。




当指针变量A赋给指针变量B时，B的操作就是对A所指向地址的数据操作。

template<class T>
LinkList<T>::LinkList(T a[],int n)
{
		Node<T>*r,*s;//第一个为尾指针
		first=new Node<T>;
		first->next=NULL;
		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;
}

不带头结点的单链表的构造
头插法：

{
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;
}

PPT47

单链表的遍历

template<class T>
LinkList<T>::PrintList()
{
	Node<T> *p;
	p->first->next;
	while(p)
	{
	cout<<p->data<<endl;
	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;
}

不带头结点的插入：

Insert(int i, T x){  
   Node<T> *p; int j;
   if（i<=0） throw “位置非法”；
   if （i==1 ）{ s=new Node<T>;s->next=head;head=s;return}
   p=first ; j=1;    //工作指针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;
    }
}