数据结构与算法--线性表的链式存储

主要内容

• 线性表的链式存储结构
• 单链表及其基本操作
• 单链表的重要基本操作
• 其他类型的链表
• 循环链表
• 双向链表（包括双向循环链表和非双向循环链表）
• 顺序表与链表的比较

1.1 线性表的链式存储结构

• 链式存储：使用一组地址任意的存储单元，依存储线性表中的各数据元素。

• 

• 顺序存储：使用一组地址连续的存储单元，依次存储线性表中每个数据元素。

• 

1.1.2 线性表的链式存储结构

• 链式存储结构中的每个存储单元称为结点，结点包含一个数据域和一个指针域。
• 数据域存放数据元素信息，指针域存放后继结点地址。
• 数据元素之间的逻辑关系通过结点中的指针表示。
• 访问链式存储结构通常由第一个结点开始，逐一访问所有结点。
• 具有n个数据元素的线性表对应的n个结点通过链接方式链接成一个链表，即为线性表的链式存储结构。
  

1.1.3 单链表

• 单链表中每个链结点仅包含一个指针域，称为线性链表或单链表。

• 结点结构：数据域 data，指针域 next。

• 

• 结构：头指针，保存链表第一个结点的地址，尾结点指针域的值为空（NULL）。

• 

1.1.4 带头结点的单链表（常用）

• 在链表的第一个结点之前附设一个结点，称为头结点。
• 头结点的引入使得单链表的头指针永远不为空，方便插入、删除操作。
  

1.1.5 单链表结点的数据类型

typedef int DataType;
struct Node {
    DataType data;
    struct Node *next;
};
typedef struct Node *head;

1.1.6 单链表与顺序表比较

2.1 单链表的基本操作

• 空表：head->next==NULL
• 表尾：p->next==NULL
• 指针后移：p=p->next
• 结点连接：p->next=q
• 前驱：若 p->next==q，则p指向q的前驱结点
• //p、q为指向任意结点的指针
  空表：head->nextNULL
  表尾：p->nextNULL
  指针后移：p=p->next
  结点连接：p->next=q （q结点放在p结点之后）
  前驱：若p->next==q，则p指向q的前驱结点
  

2.2 单链表及其基本操作（代码示例）

• 初始化单链表

//初始化单链表
int InitList (Node* &H)
{  //H为指向单链表的头指针
	H=new Node;          //分配空间，作为头结点
	if(!H)
    {
          cout<<“初始化错误”<<endl;
		return 0;
	} 
	H->next=NULL;
	return 1; 
}

• 判表空

//判表空
int ListEmpty(Node* H)
{  //H为指向单链表的头指针
	if(H->next)
		return 0;
	else //头结点指针域为空
		return 1; 
}
}

• 求单链表中当前元素的个数

//求单链表中当前元素的个数
int ListLength (Node* H)
{  //H为指向单链表的头指针
	Node *p=H->next;
	int total=0; 
	while(p){ 
		total++;      //计数器+1 
		p=p->next; //指针后移
	}
	return total; 
}

• 遍历单链表

//遍历单链表
void TraverseList(Node * H)
{  //H为指向单链表的头指针
	Node *p=H->next;
	while(p)
    { 
          cout<<p->data<<“  ”;
		p=p->next;
	}
	cout<<endl;
}

3.1 单链表的重要基本操作

• 查找结点

• 添加结点

• 删除结点

3.1.1 查找指定结点

• 设置指针p，初始指向第一个结点，顺着next域依次指向每个结点，判断是否等于指定结点。
  • 设置一个跟踪链表结点的指针p，初始时p指向链表中的第一个结点，然后顺着next域依次指向每个结点，每指向一个结点就判断其是否等于指定结点，若是，则返回该结点地址。否则继续向后搜索，直到p为NULL ，表示链表中无此元素，返回NULL。

Node *p=head->next;
while(p){
     if(p->data==…)    break;
     p=p->next;  //p指向下一结点
}

3.2 查找、插入、删除操作的代码示例

//返回第一个与指定值匹配的元素位置
int Find_item(Node * H, DataType item)
{  //H为指向单链表的头指针
	Node *p=H->next;
	int pos=0; //结点位序
	while(p)
    { //从单链表第一个结点开始顺序查找所有结点
          pos++;
		if(p->data==item) break;
		p=p->next;
	}
	if(p) return pos; //返回位置编号
	else  return 0;    //查找失败
}

//获取单链表中指定位置上的数据元素
int Find_pos(Node * H, int pos, DataType *item)
{  //H为指向单链表的头指针
	Node *p=H->next;
	int i=1; //结点位序
	while(p && i!=pos){ 
		p=p->next; i++; 
	}
	if(p==NULL){ //查找不成功，退出运行
		cout<<“位置无效"<<endl;
		return 0;
	}
	*item=p->data;
	return 1; 
}

单链表结点的插入是利用修改结点指针域的值，使其指向新的链接位置来完成插入操作，无需移动任何元素。
假定在链表中指定结点之前插入一个新结点，要完成这种插入必须首先找到所插位置的前一个结点，再进行插入。假设指针p指向待插位置的前驱结点，指针t指向新结点。
① Node *t=new Node; t->data=d;
② t->next=p->next;
③ p->next=t;

//向线性表指定位置插入一个新元素
int ListInsert (Node *H , int pos, DataType item)
{	
	Node *p=H;  int i=0;
	while( p ){ //查找pos的前驱
		if(i+1==pos) break;
		p=p->next; i++;
	}
	if(p==NULL){ //查找不成功，退出运行
		cout<<“插入位置无效"<<endl;
		return 0;
	}
	Node *t=new Node;	t->data=item; //①
	t->next=p->next; //②
	p->next=t; //③
	return 1;
}

![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/aec1eae1109843aba6943bb24564399d.p

//从线性表中删除第一个与指定值匹配的元素
int ListDelete (Node *H, DataType item)
{	
	Node *p=H, *t;
	while( p->next ){ //查找pos的前驱
		if(p->next->data==item) break;
		p=p->next; 
	}
	if(p->next==NULL){ //查找不成功，退出运行
		cout<<“删除元素不存在"<<endl;
		return 0;
	}
	t=p->next;	    //①t为被删除结点
	p->next=t->next; //②删除t的链接关系
	delete t;		   //③释放被删结点
	return 1;
}

//撤销单链表
void DestroyList (Node* &H)
{  //H为指向单链表的头指针
	Node *p;
	while(H){ 
		p=H;
		H=H->next;  // 使用H指针保存下一结点的位置
		delete p;
	}
}

4.其他类型的链表

• 循环链表
• 双向链表
  • 双向循环链表
    非双向循环链表

4.1循环链表特点

• 最后一个结点的指针域指向头结点，形成环。
• 特点：链表中最后一个结点的指针域不为空，而是
  指向头结点，从而使整个链表形成一个环。
  与单链表不同之处：
  检测链表是否为空的方法不同。
  单链表：head->next == NULL
  单循环链表：head->next == head
  判断是否遍历到链表尾的条件不同。
  单链表：p->next == NULL
  单循环链表：p->next == head
  建立空链表的操作不同。
  单链表：head->next = NULL
  单循环链表：head->next = head

带空头结点的单循环链表

• 

4.2双向链表特点

• 每个结点中既有指向后继的指针域，又有指向前驱的指针域。

• 特点:每个结点中既有指向后继的指针域，又有指向
  前驱的指针域。
  结点结构：
  typedef struct DNode{
  DataType data;
  struct DNode * prior;
  struct DNode * next;
  };
  对称性：p->prior->nextpp->next->prior
  注意：操作双向链表时需要同时考虑每个结点两个
  方向上的指针域

• 带空头结点的双向链表

• 

5.顺序表与链表的比较

• 顺序存储结构优点：简单，可随机存取，存取速度快，每个结点只存储元素信息。

• 顺序存储结构缺点：需要连续存储空间，插入和删除操作效率低。

• 链式存储结构优点：不需连续存储空间，插入和删除操作不需移动大量元素。

• 链式存储结构缺点：操作算法复杂，不能随机存取，需要额外空间表示元素间关系。

6.结论

• 顺序存储结构适合线性表长度稳定，不常插入删除，常存取查询。
• 链式存储结构适合线性表长度未知，需频繁插入删除。