数据结构——单链表、双链表c语言实现

数据结构——单链表、双链表c语言实现

链表

• 特点（缺点）：（1）非连续结构，实现结构复杂（2）不支持随机访问

• 使用场景：频繁插入删除

• 链表类型：单向、双向；带头、不带头；循环、非循环 三种属性可组成8中类型的结构

• 带尾指针的非循环链表：尾插时间复杂度O(1),尾删时间复杂度O(n)(遍历整个链表，将尾指针指向的前一个节点的next置为NULL)

• 双向循环链表：任意位置插入删除的时间复杂度都是O(1),效率较高

• 单链表实现

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

#include "SingleList.h"

void singleListInit(SingleList* sl)
{
	//空链表
	sl->_head = NULL;
}

Node* creatNode(Type data)
{
	Node* node = (Node*)malloc(sizeof(Node));
	node->_data = data;
	node->_next = NULL;
	return node;
}

void singleListPrint(SingleList* sl)
{
	Node* cur = sl->_head;
	while (cur)
	{
		printf("%d ", cur->_data);
		cur = cur->_next;
	}
	printf("\n");
}

void singleListPushFront(SingleList* sl, Type data)
{
	Node* node = creatNode(data);
	//是否为空表
	if (sl->_head == NULL)
	{
		sl->_head = node;
	}
	else
	{
		node->_next = sl->_head;
		sl->_head = node;
	}
}

void singleListPopFront(SingleList* sl)
{
	if (sl->_head)
	{
		Node* cur = sl->_head;
		sl->_head = cur->_next;
		free(cur);
	}
}

void singleListPushBack(SingleList* sl, Type data)
{
	Node* node = creatNode(data);
	if (sl->_head == NULL)
		sl->_head = node;
	else
	{
		//找到最后一个数据
		// last   newNode
		Node* last = sl->_head;
		while (last->_next)
			last = last->_next;

		//尾插
		last->_next = node;
	}	
}

void singleListPopBack(SingleList* sl)
{
	//找到最后一个节点，并且，修改被删除节点的前驱节点的执行
	if (sl->_head)
	{
		//找到最后一个节点，遍历的过程中，更新prev
		Node* prev = NULL;
		Node* tail = sl->_head;
		while (tail->_next)
		{
			prev = tail;
			tail = tail->_next;
		}
		//如果删除的为头结点， 或者链表中只要一个节点
		//和下面判断等价if (prev == NULL)
		if (tail == sl->_head)
			sl->_head = NULL;
		else
			prev->_next = NULL;

		free(tail);
	}
}


void singleListInsertAfter(Node* pos, Type data){
	Node* node = (Node*)malloc(sizeof(Node));
	node->next=pos->next;
	pos->next=node;
}

void singleListEraseAfter(Node* pos){
	Node* q=pos->next;
	pos->next=q->next;
	free(q);
}

Node* find(SingleList* sl,Type data){
	Node* cur=sl->head;
	while(cur){
		if(cur->data==data)
			return cur;
		else
			cur=cur->next;
	}
}


void singleListDestroy(SingleList* sl){
	Node* cur=sl->head;
	while(cur){
		sl->head=cur->next;
		free(cur);
		cur=sl->head;
	}
}

• 双向循环链表实现

#include "List.h"

void listInit(List* lst)
{
	//创建一个头结点, 构成循环结构
	lst->_header = creatNode(0);
	lst->_header->_next = lst->_header;
	lst->_header->_prev = lst->_header;
}
Node* creatNode(Type data)
{
	Node* node = (Node*)malloc(sizeof(Node));
	node->_prev = node->_next = NULL;
	node->_data = data;
	return node;
}

void printList(List* lst)
{
	Node* cur = lst->_header->_next;
	while (cur != lst->_header)
	{
		printf("%d ", cur->_data);
		cur = cur->_next;
	}
	printf("\n");
}

void listPushBack(List* lst, Type data)
{
	/*
	Node* node = creatNode(data);
	Node* last = lst->_header->_prev;
	// last  node  _header
	last->_next = node;
	node->_prev = last;

	node->_next = lst->_header;
	lst->_header->_prev = node;
	*/
	//尾插
	listInsert(lst->_header, data);
}

void listPopBack(List* lst)
{
	/*
	Node* last, *prev;
	//注意： 不能删除header
	if (lst->_header->_next == lst->_header)
		return;  //空链表，没有数据可以删除

	last = lst->_header->_prev;
	prev = last->_prev;
	// prev  _header
	prev->_next = lst->_header;
	lst->_header->_prev = prev;

	free(last);
	*/
	listErase(lst->_header->_prev);
}

void listPushFront(List* lst, Type data)
{
	/*
	Node* front = lst->_header->_next;
	Node* node = creatNode(data);

	node->_next = front;
	front->_prev = node;

	node->_prev = lst->_header;
	lst->_header->_next = node;
	*/
	listInsert(lst->_header->_next, data);
}

void listPopFront(List* lst)
{
	/*
	Node* front, *next;
	if (lst->_header->_next == lst->_header)
		return;

	front = lst->_header->_next;
	next = front->_next;

	free(front);
	lst->_header->_next = next;
	next->_prev = lst->_header;
	*/
	listErase(lst->_header->_next);
}

void listInsert(Node* pos, Type data)
{
	Node* prev = pos->_prev;
	Node* node = creatNode(data);
	// prev  node  pos
	prev->_next = node;
	node->_prev = prev;

	node->_next = pos;
	pos->_prev = node;
}
void listErase(Node* pos)
{
	Node* prev, *next;
	//删除当前位置的节点
	//注意： header不能删除
	if (pos->_next == pos)
		return; //空表不能删除
	prev = pos->_prev;
	next = pos->_next;
	free(pos);
	prev->_next = next;
	next->_prev = prev;
}


void listDesroy(List* lst)
{
	Node* cur = lst->_header->_next;
	while (cur != lst->_header)
	{
		Node* next = cur->_next;
		free(cur);
		cur = next;
	}
	free(lst->_header);
	lst->_header = NULL;
}