【数据结构】 单向链表与双向带头循环链表增删查改实现

一、链表的概念及结构

  概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
  实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向、双向

2. 带头、不带头

3. 循环、非循环
   链表的优缺点：
   优点：

4. 插入删除速度快，不需要像数组与顺序表那样挪数；

5. 在内存中离散式存储，内存利用率高；

6. 大小没有固定，拓展很灵活；
   缺点：

7. 不能随机访问，必须从第一个开始遍历查找，访问效率低；

二、单向链表实现

slist.h

#ifndef _slist_h_
#define _slist_h_
#include <stdio.h>
#include <stdlib.h>

typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
// 单链表的销毁
void SListDestory(SListNode** pplist);
#endif

slist.c

#include "slist.h"

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newNode = (SListNode *)malloc(sizeof(SListNode));
	newNode->data = x;
	newNode->next = NULL;
	return newNode;
}

// 单链表打印
void SListPrint(SListNode* plist)
{
	SListNode *cur = plist;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	SListNode* nowNode = BuySListNode(x);
	if (*pplist == NULL)
	{
		*pplist = nowNode;
	}
	else
	{
		SListNode *tail = *pplist;
		while (tail->next != NULL) //找尾
		{
			tail = tail->next;
		}
		tail->next = nowNode;
	}
}

// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	SListNode *nowNode = BuySListNode(x);
	nowNode->next = *pplist;
	*pplist = nowNode;
}

// 单链表的尾删
void SListPopBack(SListNode** pplist)
{
	if (*pplist == NULL)
	{
		return;
	}
	else if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SListNode *prev = NULL;
		SListNode *tail = *pplist;
		while (tail->next != NULL)
		{
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		prev->next = NULL;
	}
}

// 单链表头删   ....
void SListPopFront(SListNode** pplist)
{
	if (*pplist == NULL)
	{
		return;
	}		
	SListNode *next = (*pplist)->next;
	free(*pplist);
	*pplist = next;
}

//void SListPopFront(SListNode** ppList)
//{
//	if (*ppList)
//	{
//		SListNode* next = (*ppList)->next;
//		free(*ppList);
//		*ppList = next;
//	}
//}

// 单链表查找  ....
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	if (plist == NULL)
	{
		return NULL;
	}		
	SListNode *cur = plist;
	while(cur != NULL)
	{
		if (cur->data == x)
			return cur;
		cur = cur->next;
	}
	return NULL;
}

// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	SListNode *newNode = BuySListNode(x);
	SListNode *next = pos->next;
	pos->next = newNode;
	newNode->next = next;	
}

// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
	SListNode *next = pos->next->next;
	if (pos->next != NULL)
	{
		free(pos->next);
		pos->next = next;
	}
}

// 单链表的销毁
void SListDestory(SListNode** pplist)
{
	SListNode *cur = *pplist;
	SListNode *next = NULL;
	while (cur != NULL)
	{
		next = cur->next;
		free(cur);
		cur = next;
	}
	*pplist = NULL;
}

二、双向带头循环链表

ListNode.h

#ifndef _ListNode_h_
#define _ListNode_h_

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

// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
	LTDataType _data;
	struct ListNode* _next;
	struct ListNode* _prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* plist);
// 双向链表打印
void ListPrint(ListNode* plist);
// 双向链表尾插
void ListPushBack(ListNode* plist, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* plist);
// 双向链表头插
void ListPushFront(ListNode* plist, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* plist);
// 双向链表查找
ListNode* ListFind(ListNode* plist, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

#endif

ListNode.c

#include "ListNode.h"

ListNode* BuyListNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	node->_data = x;
	node->_prev = NULL;
	node->_next = NULL;

	return node;
}

// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	head->_prev = head;
	head->_next = head;

	return head;
}

// 双向链表销毁
void ListDestory(ListNode* plist)
{
	assert(plist);
	ListNode* cur = plist->_next;
	while (cur != plist)
	{
		ListNode* next = cur->_next;
		free(cur);
		cur = next;
	}
	free(plist);
}

// 双向链表打印
void ListPrint(ListNode* plist)
{
	assert(plist);
	ListNode* cur = plist->_next;
	while (cur != plist)
	{
		printf("%d->", cur->_data);
		cur = cur->_next;
	}
	printf("NULL\n");
}

// 双向链表尾插
void ListPushBack(ListNode* plist, LTDataType x)
{
	assert(plist);
	ListNode* newNode = BuyListNode(x);
	
	ListNode* tail = plist->_prev;
	tail->_next = newNode;
	newNode->_prev = tail;
	newNode->_next = plist;
	plist->_prev = newNode;
}

// 双向链表尾删
void ListPopBack(ListNode* plist)
{
	assert(plist);
	ListNode* newTail = plist->_prev->_prev;
	free(newTail->_next);
	newTail->_next = plist;
	plist->_prev = newTail;
}

// 双向链表头插
void ListPushFront(ListNode* plist, LTDataType x)
{
	assert(plist);
	ListNode* newNode = BuyListNode(x);

	newNode->_next = plist->_next;
	newNode->_prev = plist;
	plist->_next->_next = newNode;
	plist->_next = newNode;
}

// 双向链表头删
void ListPopFront(ListNode* plist)
{
	assert(plist);

	ListNode* cur = plist->_next->_next;
	free(cur->_prev);
	plist->_next = cur;
	cur->_prev = plist;
}

// 双向链表查找
ListNode* ListFind(ListNode* plist, LTDataType x)
{
	assert(plist);
	ListNode* cur = plist->_next;

	while (cur != plist)
	{
		if (cur->_data == x)
			return cur;
		else
			cur = cur->_next;
	}
	return NULL;
}

// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* newNode = BuyListNode(x);
	ListNode* prev = pos->_prev;
	prev->_next = newNode;
	newNode->_prev = prev;
	newNode->_next = pos;
	pos->_prev = newNode;
}

// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
	pos->_prev->_next = pos->_next;
	pos->_next->_prev = pos->_prev;
	free(pos->_prev);
}