数据结构—双向链表

双向链表

主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next指向下一个节点。

结构：

节点（Node）：每个节点包含三部分：
数据（Data）：存储节点的值。
前指针（Prev）：指向链表中前一个节点的指针。
后指针（Next）：指向链表中下一个节点的指针。

#ifndef __DOULINK_H__
#define __DOULINK_H__

#include <pthread.h>

typedef struct stu
{
	int id;
	char name[32];
	int score;
}DataType;


typedef struct dnode
{
	DataType data;
	struct dnode *ppre;
	struct dnode *pnext;
}DLink_Node_t;

typedef struct dlink
{
	DLink_Node_t *phead;
	int clen;
	pthread_mutex_t mutex;
}DLink_t;


extern DLink_t *create_doulink();
extern int push_doulink_head(DLink_t *pdoulink, DataType data);
extern void doulink_for_each(DLink_t *pdoulink, int dir);

在双向链表中同样可以实现单向链表中的头插，尾插，头删等操作。

此外，如用到结构体，结构体可以整体赋值。

特点：单向遍历：单向链表只能从头节点开始，按顺序向下遍历，直到链表的末尾。无法逆向遍历。
内存占用较少：每个节点只需要一个指针（指向下一个节点），因此占用的内存相对较少。
操作复杂度：
插入节点：在链表头插入效率较高，但在链表尾部插入需要遍历整个链表。
删除节点：如果要删除特定节点，需要从头遍历到目标节点的前一个节点
双向链表

特点：

双向遍历：可以从链表的头节点向后遍历，也可以从链表的尾节点向前遍历。这种双向遍历特性使得某些操作更加灵活。
内存占用较多：每个节点需要两个指针（指向前一个节点和后一个节点），因此占用的内存比单向链表多。
操作复杂度：
插入节点：可以在链表的任意位置高效地插入节点，因为可以通过前后指针直接找到所需位置。
删除节点：由于可以通过前指针找到前一个节点，因此删除操作也更加高效。
使用单向链表的情况
内存有限：

内存占用：单向链表每个节点只包含一个指针，因此占用的内存较少。如果内存资源非常有限，单向链表是更合适的选择。
只需要单向遍历：

简单遍历：当只需要从头到尾的单向遍历时，单向链表更简单高效。例如，队列（FIFO）的实现通常使用单向链表，因为只需要从头部插入，从尾部删除。
操作集中在链表的头部：

高效插入和删除：如果插入和删除操作主要集中在链表的头部（如栈的实现），单向链表的效率更高，因为只需调整头指针即可。
数据的插入顺序较为简单：

顺序存储：如果数据的插入顺序是线性的且不需要复杂的插入操作（例如，追加到链表尾部），单向链表足够满足需求。
使用双向链表的情况
需要双向遍历：

双向访问：如果需要从任意节点向前或向后遍历链表，双向链表是必要的。例如，双向链表适用于实现双端队列（Deque），其中可以从两端进行插入和删除操作。
频繁插入和删除操作：

任意位置的高效操作：双向链表可以在链表的任意位置高效地插入或删除节点，因为可以通过前后指针快速找到前驱和后继节点。例如，某些缓存系统使用双向链表来管理元素的插入和删除，以便在 O(1) 时间内更新链表。
需要从尾部高效操作：

尾部插入/删除：如果需要频繁从链表尾部进行插入或删除操作，双向链表是更好的选择，因为你可以直接访问尾节点，而无需遍历整个链表。
实现复杂数据结构：

复杂数据结构：某些复杂的数据结构，如自平衡二叉搜索树或图的邻接表，可能需要双向链表来更灵活地管理节点和指针。

1.创建双向链表

DLink_t *create_doulink()
{
	DLink_t *pdoulink = malloc(sizeof(DLink_t));
	if (NULL == pdoulink)
	{
		perror("fail malloc");
		return NULL;
	}
	pdoulink->phead = NULL;
	pdoulink->clen = 0;
	pthread_mutex_init(&(pdoulink->mutex), NULL);

	return pdoulink;
}

2.头插法

int push_doulink_head(DLink_t *pdoulink, DataType data)
{
	DLink_Node_t *pnode = malloc(sizeof(DLink_Node_t));
	if (NULL == pnode)
	{
		perror("fail malloc");
		return -1;
	}
	pnode->data = data;
	pnode->ppre = NULL;
	pnode->pnext = NULL;
	
	if (is_empty_doulink(pdoulink))
	{
		pdoulink->phead = pnode;
	}
	else
	{
		pnode->pnext = pdoulink->phead;
		pdoulink->phead->ppre = pnode;
		pdoulink->phead = pnode;
	}
	pdoulink->clen++;

	return 0;
}	

3.判空函数

int is_empty_doulink(DLink_t *pdoulink)
{
	return NULL == pdoulink->phead;
}

4.遍历链表

void doulink_for_each(DLink_t *pdoulink, int dir)
{
	if (is_empty_doulink(pdoulink))
		return;
	
	DLink_Node_t *p = pdoulink->phead;
	if (dir)
	{
		while (p != NULL)
		{
			printf("%d %s %d\n", p->data.id, p->data.name, p->data.score);
			p = p->pnext;
		}
	}
	else
	{
		while (p->pnext != NULL)
		{
			p = p->pnext;
		}
		while (p != NULL)
		{
			printf("%d %s %d\n", p->data.id, p->data.name, p->data.score);
			p = p->ppre;
		}
	}
	printf("\n");

}

5.主函数

#include <stdio.h>
#include "doulink.h"

int main(int argc, const char *argv[])
{
	DLink_t *pdoulink = create_doulink();
	if (NULL == pdoulink)
	{
		return -1;
	}
	
	DataType stus[] = {{1, "zhangsan", 99},
						{2, "lisi", 78},
						{3, "wanger", 88},
						{4, "zhaowu", 57},
						{5, "maliu", 76}};

	push_doulink_head(pdoulink, stus[0]);
	push_doulink_head(pdoulink, stus[1]);
	push_doulink_head(pdoulink, stus[2]);

	doulink_for_each(pdoulink, 1);
	doulink_for_each(pdoulink, 0);

	return 0;
}

6.查找链表元素函数

DLink_Node_t *find_doulink(DLink_t *pdoulink, char *name)
{
	if (is_empty_doulink(pdoulink))
		return NULL;
	
	DLink_Node_t *pnode = pdoulink->phead;
	while (pnode != NULL)
	{
		if (!strcmp(name, pnode->data.name))
		{
			return pnode;
		}
		pnode = pnode->pnext;
	}

	return NULL;
}

7.改变链表元素函数

int change_doulink(DLink_t *pdoulink, char *name, int score)
{
	DLink_Node_t *pnode = find_doulink(pdoulink, name);
	if (NULL != pnode)
	{
		pnode->data.score = score;
		return 0;
	}
	
	return -1;
}

8.销毁函数

void destroy_doulink(DLink_t *pdoulink)
{
	while (!is_empty_doulink(pdoulink))
	{
		pop_doulink_head(pdoulink);
	}
	free(pdoulink);
}

9.指定元素删除函数

int pop_point_node(DLink_t *pdoulink, char *name)
{
	if (is_empty_doulink(pdoulink))
		return 0;
	
	DLink_Node_t *pdel = find_doulink(pdoulink, name);
	if (NULL == pdel)
	{
		return 0;
	}
	if (NULL == pdel->ppre)
	{
		pop_doulink_head(pdoulink);
	}
	else if (NULL == pdel->pnext)
	{
		pop_doulink_tail(pdoulink);
	}
	else
	{
		pdel->ppre->pnext = pdel->pnext;
		pdel->pnext->ppre = pdel->ppre;
		free(pdel);
		pdoulink->clen--;
	}

	return 1;
}