链表实现分析+双向链表（快速实现）

链表概念

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
其结构如下：

链表的分类

• 单向、双向
• 带头、不带头
• 循环、不循环
  按照上述的描述可以将链表分为8类。
  下面介绍常用的两类：

• 无头单向非循环链表
  
  特点：
  结构简答，实际中多维其他数据结构的子结构。如哈希桶、图的邻接表等。

• 带头双向循环链表
  
  特点：结构最复杂，一般用来单独存储数据。实现起来简单。

链表的实现

下面选择几个比较特别的，画图解释如何实现链表。工程代码详见：链表实现代码。
单向链表主要实现接口：

typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;
void SListPrint(SLTNode* plist);
void SListPushBack(SLTNode** pplist, SLTDataType x);
void SListPushFront(SLTNode** pplist, SLTDataType x);
void SListPopBack(SLTNode** pplist);
void SListPopFront(SLTNode** pplist);
//查找 修改
SLTNode* SListFind(SLTNode* plist, SLTDataType x);
//插入 后面插入
void SListInsertAfter(SLTNode* pos, SLTDataType x);
// 单链表在pos位置之前插入 
void SListInsertBefore(SLTNode** pplist, SLTNode* pos, SLTDataType x);
void SListEraseAfter(SLTNode* pos);
void SListEraseCur(SLTNode** plist, SLTNode* pos);

尾插

void SListPushBack(SLTNode** pplist, SLTDataType x)

{
	SLTNode* newnode = BuySLTNode(x);

	if (*pplist == NULL){
		*pplist = newnode;
	}
	else{
		SLTNode* tail = *pplist;
		while (tail->next != NULL){
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

头插

void SListPushFront(SLTNode** pplist, SLTDataType x)
{
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pplist;
	*pplist = newnode;
}

尾删

void SListPopBack(SLTNode** pplist)
{
	// 1、没有节点
	// 2、一个节点
	// 3、多个节点
	if (*pplist == NULL)
	{
		return;
	}
	else if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SLTNode* prev = NULL;
		SLTNode* tail = *pplist;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;

		prev->next = NULL;
	}
}

头删

//头删
void SListPopFront(SLTNode** pplist)
{
	//若为空
	if (*pplist == NULL)
	{
		return;
	}
	else//不空，删除头
	{
		SLTNode* next = (*pplist)->next;
		free(*pplist);

		*pplist = next;
	}
}

指定位置之前插入数据

其余的部分和上述方法相似，只要使用上述的方法画图分析即可。

总结单向无头链表

• 传递二级指针，用于头指针不要修改的情况下。
• 一般使用三指针法，画图解决问题。

带头双向循环链表

带头双向训话链表有两个指针，一个指针之前前面数据，另一个指针之前后面。第一个节点prev指向最后一个节点。最后一个节点next指针指向第一个节点。
如图：

typedef int LTDataType;
typedef struct ListNode{
	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;
}ListNode;

总体实现代码：双向链表实现，此工程讲述了双向链表的实现。

接口介绍

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int LTDataType;
typedef struct ListNode{

	LTDataType data;
	struct ListNode* prev;
	struct ListNode* next;

}ListNode;

void ListPrint(ListNode* phead);
ListNode* BuyNode(LTDataType x);
ListNode* ListCreate();
void ListPushBack(ListNode* phead, LTDataType x);
void ListPushFront(ListNode* phead, LTDataType x);
void ListPopBack(ListNode* phead);
void ListPopFront(ListNode* phead);
ListNode* ListFind(ListNode* phead,LTDataType x);
void  ListInsert(ListNode* pos, LTDataType x);
void ListErase(ListNode* pos);

//接口
//空返回1，非空返回0
int ListEmpty(ListNode* phead);
int ListSize(ListNode* phead);
void ListDestory(ListNode* phead);

链表初始化

 ListNode* ListCreate()
{
	 ListNode* phead = BuyNode(0);
	 phead->next = phead;
	 phead->prev = phead;
	 return phead;
}

申请链表节点

ListNode* BuyNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	node->next = NULL;
	node->prev = NULL;
	node->data = x;
	return node;
}

插入节点

因为有两个指针，所以操作起来特别方便。

void  ListInsert(ListNode* pos, LTDataType x)
{
	//pos在最开始，等于尾插，由于phead不变
	assert(pos);
	ListNode* prev = pos->prev;
	ListNode* newnode = BuyNode(x);
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

删除节点

void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* prev = pos->prev;
	ListNode* next = pos->next;

	prev->next = next;
	next->prev = prev;

	free(pos);
}

判空

int ListEmpty(ListNode* phead)
{
	assert(phead);
	return phead->next == phead ? 1 : 0;
}

销毁

void ListDestory(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead){
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	phead = NULL;//不起作用（改变的形参），传二级指针
}

如何快速实现双向链表

//带头 双向 循环
 ListNode* ListCreate()
{
	 ListNode* phead = BuyNode(0);
	 phead->next = phead;
	 phead->prev = phead;
	 return phead;
}
void ListPrint(ListNode* phead)
{
	ListNode* cur = phead->next;
	while (cur != phead){
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
ListNode* BuyNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	node->next = NULL;
	node->prev = NULL;
	node->data = x;
	return node;
}
void ListPushFront(ListNode* phead, LTDataType x)
{
	ListInsert(phead->next, x);//头插
}
void ListPushBack(ListNode* phead, LTDataType x)
{
	ListInsert(phead, x);//尾插，头的之前插入
}
void ListPopBack(ListNode* phead)
{
	ListErase(phead->prev);//尾删，删除头的前驱指针
}
void ListPopFront(ListNode* phead)
{
	ListErase(phead->next);//头删
}
ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead){
		if (cur->data == x){
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
void  ListInsert(ListNode* pos, LTDataType x)
{
	//pos在最开始，等于尾插，由于phead不变
	assert(pos);
	ListNode* prev = pos->prev;
	ListNode* newnode = BuyNode(x);
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}

void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* prev = pos->prev;
	ListNode* next = pos->next;
	prev->next = next;
	next->prev = prev;
	free(pos);
}

int ListEmpty(ListNode* phead)
{
	assert(phead);
	return phead->next == phead ? 1 : 0;
}
void ListDestory(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead){
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	phead = NULL;//不起作用（改变的形参），传二级指针
}

熟悉指针用法，画图分析会事半功倍。