基础：基于链表的空闲队列与工作队列示例

0 简介

本示例使用最基础的链表结构体，演示了空闲队列与工作队列的使用方式。主要构建了两个函数：insertToTail()和getFromHead()。其中，insertToTail()用于向一个链表的尾部插入一个元素，getFromHead()用于从一个链表的头部摘取一个元素。
主函数的执行流程是：
1.首先静态分配10个链表元素；
2.然后依次将这10个元素插入到由指针freeListPtr指向的空闲队列的尾部，插入完成后，输出空闲链表当前长度，并从链表头部依次打印这10个元素的数据值；
3.接着，从空闲链表的头部依次摘取元素，将其插入到由指针workListPtr指向的工作队列的尾部，并从链表头部依次打印这10个元素的数据值。

1 代码示例

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

/*链表节点结构体*/
typedef struct listNode
{
	int data;									//数据
	struct listNode *next;						//指向下一个节点的指针

} LIST_NODE, *LIST_NODE_PTR;


/*链表结构体*/
typedef struct linkList
{
	int len;									//链表长度
	LIST_NODE_PTR head;							//链表头部
	LIST_NODE_PTR tail;							//链表尾部

} LINK_LIST, *LINK_LIST_PTR;


/*
*函数名：insertToTail
*功能：从链表尾部插入元素
*参数：
*	linkListPtr：链表指针
*	listNodePtr：链表节点指针
*返回值:空
*/
void insertToTail(LINK_LIST_PTR linkListPtr, LIST_NODE_PTR listNodePtr)
{
	if (linkListPtr->len == 0)
	{
		linkListPtr->head = listNodePtr;
		linkListPtr->tail = listNodePtr;
	}
	else
	{
		linkListPtr->tail->next = listNodePtr;
		linkListPtr->tail = listNodePtr;
	}

	linkListPtr->len++;
}

/*
*函数名：getFromHead
*功能：从链表头部获取元素，获取后将从链表上去掉该元素
*参数：
*	linkListPtr：链表指针

*返回值:链表节点指针
*/
LIST_NODE_PTR getFromHead(LINK_LIST_PTR linkListPtr)
{
	LIST_NODE_PTR temp=NULL;

	if (linkListPtr->len == 0)
	{
		return NULL;
	}
	else if(linkListPtr->len == 1)
	{
		temp = linkListPtr->head;
		linkListPtr->head=NULL;
		linkListPtr->tail=NULL;
	}
	else
	{
		temp = linkListPtr->head;
		linkListPtr->head = linkListPtr->head->next;
	}
	linkListPtr->len--;

	return temp;
}


int main()
{
	LINK_LIST_PTR freeListPtr;							//空闲链表指针
	LINK_LIST_PTR workListPtr;							//工作链表指针

	LIST_NODE listNode[10];								//静态分配10个链表元素
	LIST_NODE_PTR temp=NULL;
	int i=0;

	memset(listNode,0,sizeof(LIST_NODE)*10);

	for(i=0;i<10;i++)
	{
		listNode[i].data=i;
		listNode[i].next=NULL;
	}

	freeListPtr=(LINK_LIST_PTR)malloc(sizeof(LINK_LIST));
	if(freeListPtr == NULL)
	{
		printf("malloc freeListPtr error.\n");
		return -1;
	}
	freeListPtr->len=0;

	workListPtr=(LINK_LIST_PTR)malloc(sizeof(LINK_LIST));
	if(workListPtr == NULL)
	{
		printf("malloc workListPtr error.\n");
		return -1;
	}
	workListPtr->len=0;

	
	for(i=0;i<10;i++)
	{
		insertToTail(freeListPtr,&listNode[i]);						//将10个元素依次插入空闲链表尾部
	}

	printf("list len =%d\n",freeListPtr->len);

	temp=freeListPtr->head;

	while(temp!=NULL)
	{
		printf("free data=%d\n",temp->data);
		temp=temp->next;
	}


	for(i=0;i<10;i++)
	{
		insertToTail(workListPtr,getFromHead(freeListPtr));			//依次从空闲链表头部获取元素，然后插入到工作链表的尾部		
	}

	temp=workListPtr->head;

	while(temp!=NULL)
	{
		printf("work data=%d\n",temp->data);
		temp=temp->next;
	}

	return (0);
}

2 运行结果

list len =10
free data=0
free data=1
free data=2
free data=3
free data=4
free data=5
free data=6
free data=7
free data=8
free data=9
work data=0
work data=1
work data=2
work data=3
work data=4
work data=5
work data=6
work data=7
work data=8
work data=9
请按任意键继续. . .