原理:
由于栈是先进后出的,所以,让数据先进入一个栈中,然后依次从栈顶弹出,在依次进入另一个栈中,最后,从另一个栈中弹出,并输出,这样就变为先进先出了,实现了我们的队列
实现代码
//linklist.h
#ifndef __LINKLIST_H__
#define __LINKLIST_H__
typedef struct linklistnode {
struct linklistnode *next;
int item; //自身的一些数据和其他的数据
}LinkListNode;
typedef struct linklist {
LinkListNode header;
int length;
}LinkList;
LinkList *LinkList_Create();
void LinkList_Destroy(LinkList *list);
void LinkList_Clear(LinkList *list);
int LinkList_Length(LinkList *list);
int LinkList_Insert(LinkList *list, LinkListNode *node, int pos);
LinkListNode *LinkList_Get(LinkList *list, int pos);
LinkListNode *LinkList_Delete(LinkList *list, int pos);
#endif //__LINKLIST_H__
//linklist.c
#include <stdlib.h>
#include "linklist.h"
LinkList *LinkList_Create()
{
LinkList *ret = NULL;
ret = malloc(sizeof(LinkList));
if ( ret != NULL ) {
ret->length = 0;
ret->header.next = NULL;
}
return ret;
}
void LinkList_Destroy(LinkList *list)
{
free(list);
}
void LinkList_Clear(LinkList *list)
{
if ( list != NULL ) {
list->length = 0;
list->header.next = NULL;
}
}
int LinkList_Length(LinkList *list)
{
int ret = -1;
if ( list != NULL ) {
ret = list->length;
}
return ret;
}
int LinkList_Insert(LinkList *list, LinkListNode *node, int pos)
{
int ret = list!=NULL && node!=NULL && pos>=0;
if ( ret ) {
int i;
LinkListNode *cur = (LinkListNode*)list;
for (i=0; i<pos && cur->next!=NULL; i++) {
cur = cur->next;
}
node->next = cur->next;
cur->next = node;
list->length++;
}
return ret;
}
LinkListNode *LinkList_Get(LinkList *list, int pos)
{
LinkListNode *ret = NULL;
if ( list!=NULL && (0<=pos && pos<list->length) ) {
int i;
LinkListNode *cur = (LinkListNode*)list;
for (i=0; i<pos; i++)
cur = cur->next;
ret = cur->next;
}
return ret;
}
LinkListNode *LinkList_Delete(LinkList *list, int pos)
{
LinkListNode *ret = NULL;
if ( list!=NULL && (0<=pos&&pos<list->length) ) {
int i;
LinkListNode *cur = (LinkListNode*)list;
for (i=0; i<pos; i++)
cur = cur->next;
ret = cur->next;
cur->next = ret->next;
list->length--;
}
return ret;
}
//linkstack.h
#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__
typedef struct linkstacknode {
struct linkstacknode *next;
void *item;
}LinkStackNode;
typedef void LinkStack;
LinkStack *LinkStack_Create();
void LinkStack_Destroy(LinkStack *stack);
void LinkStack_Clear(LinkStack *stack);
int LinkStack_Push(LinkStack *stack, void *item);
void *LinkStack_Pop(LinkStack *stack);
void *LinkStack_Top(LinkStack *stack);
int LinkStack_Size(LinkStack *stack);
#endif //__LINKSTACK_H__
//linkstack.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linkstack.h"
#include "linklist.h"
LinkStack *LinkStack_Create()
{
return LinkList_Create();
}
void LinkStack_Destroy(LinkStack *stack)
{
LinkStack_Clear(stack);
LinkList_Destroy(stack);
}
void LinkStack_Clear(LinkStack *stack)
{
while ( LinkStack_Size(stack) > 0 )
LinkStack_Pop(stack);
}
int LinkStack_Push(LinkStack *stack, void *item)
{
LinkStackNode *node = malloc(sizeof(LinkStackNode));
int ret = stack!=NULL && item!=NULL && node!=NULL;
if ( ret ) {
memset(node, 0x00, sizeof(*node));
node->item = item;
ret = LinkList_Insert(stack, (LinkListNode*)node, 0);
}
if ( !ret ) {
free(node);
}
return ret;
}
void *LinkStack_Pop(LinkStack *stack)
{
LinkStackNode *node = NULL;
void *ret = NULL;
node = (LinkStackNode*)LinkList_Delete(stack, 0);//返回要删除的节点,给node
if ( node != NULL ) {
ret = node->item;
free(node);
}
return ret;
}
void *LinkStack_Top(LinkStack *stack)
{
LinkStackNode *node= NULL;
void *ret = NULL;
node = (LinkStackNode*)LinkList_Get(stack, 0);
if ( node != NULL ) {
ret = node->item;
}
return ret;
}
int LinkStack_Size(LinkStack *stack)
{
return LinkList_Length(stack);
}
//squeue.h
#ifndef __SQUEUE_H__
#define __SQUEUE_H__
#include "linkstack.h"
typedef struct squeue
{
LinkStack *inStack; //进数据的栈
LinkStack *outStack; //出数据的栈
}SQueue;
SQueue *SQueue_Create();
void SQueue_Destroy(SQueue *queue);
void SQueue_Clear(SQueue *queue);
int SQueue_Append(SQueue *queue, void *item);
void *SQueue_Retrieve(SQueue *queue);
void *SQueue_Header(SQueue *queue);
int SQueue_Length(SQueue *queue);
#endif //__SQUEUE_H__
//squeue.c
#include <stdio.h>
#include <stdlib.h>
#include "linkstack.h"
#include "squeue.h"
SQueue *SQueue_Create()
{
SQueue *ret = malloc(sizeof(SQueue));
if( ret!=NULL )
{
ret->inStack = LinkStack_Create();
ret->outStack = LinkStack_Create();
//只要有一个栈创建失败了,那么我们就应该把我们创建的栈给销毁掉
if( ret->inStack==NULL || ret->outStack==NULL )
{
LinkStack_Destroy(ret->inStack);
LinkStack_Destroy(ret->outStack);
free(ret);
ret = NULL;
}
}
return ret;
}
void SQueue_Destroy(SQueue *queue)
{
SQueue_Clear(queue);
free(queue);
}
void SQueue_Clear(SQueue *queue)
{
if( queue!=NULL )
{
LinkStack_Clear(queue->inStack);
LinkStack_Clear(queue->outStack);
}
}
//入队
int SQueue_Append(SQueue *queue, void *item)
{
int ret = queue!=NULL;
if( ret )
{
ret = LinkStack_Push(queue->inStack, item);
}
return ret;
}
//出队
void *SQueue_Retrieve(SQueue *queue)
{
void *ret = NULL;
if( queue != NULL )
{
if( LinkStack_Size(queue->outStack) == 0 ) //out为空的时候
{
while ( LinkStack_Size(queue->inStack) > 0 )//同时in不为空,那么
{
LinkStack_Push(queue->outStack, LinkStack_Pop(queue->inStack));
//从in里面弹出,并进入out里面
}
}
ret = LinkStack_Pop(queue->outStack); //out不为空的时候,直接让它弹出
}
return ret;
}
//队头
void *SQueue_Header(SQueue *queue)
{
void *ret = NULL;
if( queue != NULL )
{
if( LinkStack_Size(queue->outStack) == 0 ) //out为空的时候
{
while ( LinkStack_Size(queue->inStack) > 0 )//同时in不为空,那么
{
LinkStack_Push(queue->outStack, LinkStack_Pop(queue->inStack));
//从in里面弹出,并进入out里面
}
}
ret = LinkStack_Top(queue->outStack); //out不为空的时候,直接让Top取出
}
return ret;
}
//求长度
int SQueue_Length(SQueue *queue)
{
int ret = -1;
if( queue != NULL )
{
ret = LinkStack_Size(queue->inStack) + LinkStack_Size(queue->outStack);
}
return ret;
}
//main.c
#include <stdio.h>
#include <stdlib.h>
#include "squeue.h"
int main( void )
{
SQueue *queue = SQueue_Create();
int i;
int a[5] = {11,22,33,44,55};
for(i=0; i<5; i++)
{
SQueue_Append(queue, a+i);
}
//SQueue_Append(queue, a);
while ( SQueue_Length(queue) > 0 )
{
printf("%d ",*(int *)SQueue_Retrieve(queue));
}
printf("\n");
SQueue_Destroy(queue);
return 0;
}
//Makefile
.PHONY : main clean
CC=gcc -g
main: main.o linklist.o linkstack.o squeue.o
$(CC) $^ -o $@
clean:
rm -rf *.o main