双向链表的学习

双向链表是一种数据结构，它由节点组成，每个节点包含两个指针：一个指向前一个节点，另一个指向后一个节点。这种结构允许双向访问，即既可以向前遍历（像单链表一样），也可以向后遍历。这使得在插入和删除元素时效率较高，因为只需要改变相邻节点的指针即可，而不需要像数组那样移动大量元素。

以下是双向链表的一些关键特性：

1. 首节点和尾节点：通常有特定的标识符表示头结点和尾结点，它们没有前驱或后继节点。
2. 插入和删除操作：相对于单链表，可以在头部、尾部以及任意位置轻松地添加或移除节点。
3. 访问元素：通过当前节点的指针可以向前或向后移动到相邻节点。

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



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;
}

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

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;
}	


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");

}


int push_doulink_tail(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->pnext =NULL;
	pnode->ppre = NULL;
	
	if (is_empty_doulink(pdoulink))
	{
		pdoulink->phead = pnode;
	}
	else
	{
		DLink_Node_t *p = pdoulink->phead;
		while (p->pnext != NULL)
		{
			p = p->pnext;
		}
		p->pnext = pnode;
		pnode->ppre = p;
	}
	pdoulink->clen++;

	return 0;
}

int pop_doulink_head(DLink_t *pdoulink)
{
	if (is_empty_doulink(pdoulink))
		return 0;

	DLink_Node_t *pdel = pdoulink->phead;
	pdoulink->phead = pdoulink->phead->pnext;
	free(pdel);
	if (pdoulink->phead != NULL)
	{
		pdoulink->phead->ppre = NULL;
	}
	pdoulink->clen--;

	return 1;
}

int pop_doulink_tail(DLink_t *pdoulink)
{
	if (is_empty_doulink(pdoulink))
		return 0;

	DLink_Node_t *pdel = pdoulink->phead;
	while (pdel->pnext != NULL)
	{
		pdel = pdel->pnext;
	}
	
	if (pdel->ppre != NULL)
	{
		pdel->ppre->pnext = NULL;
	}
	else
	{
		pdoulink->phead = NULL;
	}
	free(pdel);
	pdoulink->clen--;
	
	return 1;
}


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;
}

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;
}


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

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;
}