一步一步学数据结构之1--1（栈--两个队列实现）

 

       当看到用两个栈实现队列以后，大家有没有兴趣用两个队列实现一个栈呢，呵呵！现在就来介绍用两个队列实现一个栈。

      

       如图

这里介绍队列的常用操作：

l 创建栈

l 销毁栈

l 清空栈

l 压栈

l 出栈

l 返回栈顶元素

l 返回栈的大小

代码总分为三个文件：

QStack.h ： 放置功能函数的声明，以及表的声明 

QStack.c ： 放置功能函数的定义，以及表的定义

Main.c   ： 主函数，使用功能函数完成各种需求，一般用作测试

整体结构图为：

 

这里详细说下压栈操作，出栈操作和返回栈顶元素操作：

 

压栈操作：

int QStack_Push(QStack* stack, void* item)
{
	TQStack* aStack = (TQStack*)stack;
	
	int ret = (NULL!=aStack) && (NULL!=item);
	
	if(ret)
	{
		if(0 == LinkQueue_Length(aStack->queue_A))
		{
			ret = LinkQueue_Append(aStack->queue_B, item);	
		}
		else
		{
			ret = LinkQueue_Append(aStack->queue_A, item);
		}
		
	}
	
	return ret;
}

如图：

  

出栈操作：

void* QStack_Pop(QStack* stack)
{
	TQStack* aStack = (TQStack*)stack;
	
	void* ret = NULL;
	
	if((NULL!=aStack) && (0<QStack_Length(aStack)))
	{
		if(0 == LinkQueue_Length(aStack->queue_B))
		{
			while(LinkQueue_Length(aStack->queue_A) > 1)
			{
				LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));
			}
			
			ret = LinkQueue_Retrieve(aStack->queue_A);
		}
		else 
		{
			while(LinkQueue_Length(aStack->queue_B) > 1)
			{
				LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));
			}
			
			ret = LinkQueue_Retrieve(aStack->queue_B);
		}
	}
	
	return ret;
}

如图：

返回栈顶元素：

void* QStack_Top(QStack* stack)
{
	TQStack* aStack = (TQStack*)stack;
	
	void* ret = NULL;
	
	if((NULL!=aStack) && (0<QStack_Length(stack)))
	{
		if(0 == LinkQueue_Length(aStack->queue_B))
		{
			while(LinkQueue_Length(aStack->queue_A) > 1)
			{
				LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));
			}
			
			ret = LinkQueue_Header(aStack->queue_A);
			LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));
		}
		else
		{
			while(LinkQueue_Length(aStack->queue_B) > 1)
			{
				LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));
			}
			
			ret = LinkQueue_Header(aStack->queue_B);
			LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));
		}
	}
	
	return ret;
}

如图：

           

OK! 上代码：

QStack.h ： 

#ifndef _QSTACK_H_
#define _QSTACK_H_

typedef void QStack;

QStack* QStack_Create();

void QStack_Destroy(QStack* stack);

void QStack_Clear(QStack* stack);

int QStack_Push(QStack* stack, void* item);

void* QStack_Pop(QStack* stack);

void* QStack_Top(QStack* stack);

int QStack_Length(QStack* stack);

#endif

 

QStack.c ：

#include <malloc.h>
#include "LinkQueue.h"
#include "QStack.h"

typedef struct _tag_QStack
{
	LinkQueue* queue_A;
	LinkQueue* queue_B;
}TQStack;

QStack* QStack_Create()
{
	TQStack* ret = (TQStack*)malloc(sizeof(TQStack));
	
	if(NULL != ret)
	{
		ret->queue_A = LinkQueue_Create();
		ret->queue_B = LinkQueue_Create();
		
		if((NULL==ret->queue_A) || (NULL==ret->queue_B))
		{
			LinkQueue_Destroy(ret->queue_A);
			LinkQueue_Destroy(ret->queue_B);
			
			free(ret);
			ret = NULL;
		}
	}
	
	return ret;
}

void QStack_Destroy(QStack* stack)
{
	QStack_Clear(stack);
	
	free(stack);	
}

void QStack_Clear(QStack* stack)
{
	while(QStack_Length(stack) > 0)
	{
		QStack_Pop(stack);
	}
}

int QStack_Push(QStack* stack, void* item)
{
	TQStack* aStack = (TQStack*)stack;
	
	int ret = (NULL!=aStack) && (NULL!=item);
	
	if(ret)
	{
		if(0 == LinkQueue_Length(aStack->queue_A))
		{
			ret = LinkQueue_Append(aStack->queue_B, item);	
		}
		else
		{
			ret = LinkQueue_Append(aStack->queue_A, item);
		}
		
	}
	
	return ret;
}

void* QStack_Pop(QStack* stack)
{
	TQStack* aStack = (TQStack*)stack;
	
	void* ret = NULL;
	
	if((NULL!=aStack) && (0<QStack_Length(aStack)))
	{
		if(0 == LinkQueue_Length(aStack->queue_B))
		{
			while(LinkQueue_Length(aStack->queue_A) > 1)
			{
				LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));
			}
			
			ret = LinkQueue_Retrieve(aStack->queue_A);
		}
		else 
		{
			while(LinkQueue_Length(aStack->queue_B) > 1)
			{
				LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));
			}
			
			ret = LinkQueue_Retrieve(aStack->queue_B);
		}
	}
	
	return ret;
}

void* QStack_Top(QStack* stack)
{
	TQStack* aStack = (TQStack*)stack;
	
	void* ret = NULL;
	
	if((NULL!=aStack) && (0<QStack_Length(stack)))
	{
		if(0 == LinkQueue_Length(aStack->queue_B))
		{
			while(LinkQueue_Length(aStack->queue_A) > 1)
			{
				LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));
			}
			
			ret = LinkQueue_Header(aStack->queue_A);
			LinkQueue_Append(aStack->queue_B, LinkQueue_Retrieve(aStack->queue_A));
		}
		else
		{
			while(LinkQueue_Length(aStack->queue_B) > 1)
			{
				LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));
			}
			
			ret = LinkQueue_Header(aStack->queue_B);
			LinkQueue_Append(aStack->queue_A, LinkQueue_Retrieve(aStack->queue_B));
		}
	}
	
	return ret;
}

int QStack_Length(QStack* stack)
{
	TQStack* aStack = (TQStack*)stack;
	
	int ret = -1;
	
	if(NULL != aStack)
	{
		ret = LinkQueue_Length(aStack->queue_B) +
			  LinkQueue_Length(aStack->queue_A);
	}
	
	return ret;
}

 

Main.c     ：

            

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

int main(void)
{
	QStack* stack = QStack_Create();
	
	int a[10];
	int i = 0;

	for(i=0; i<10; i++)
	{
		a[i] = i;
		
		QStack_Push(stack, a+i);
	}
	
	printf("Header:   %d
", *(int*)QStack_Top(stack));
	printf("Length:   %d

", QStack_Length(stack));
	
	while(QStack_Length(stack) > 0)
	{
		printf("Pop:  %d
", *(int*)QStack_Pop(stack));
	}
	printf("
");
	
	for(i=0; i<6; i++)
	{
		a[i] = i+10;
		
		QStack_Push(stack, a+i);
	}
	
	while(QStack_Length(stack) > 0)
	{
		printf("Pop:  %d
", *(int*)QStack_Pop(stack));
	}
	
	QStack_Destroy(stack);
	
	return 0;
}