您的位置：首页 > 理论基础 > 数据结构算法

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

2013-08-06 18:45 405 查看

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

如图

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

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\n", *(int*)QStack_Top(stack));
printf("Length:   %d\n\n", QStack_Length(stack));

while(QStack_Length(stack) > 0)
{
printf("Pop:  %d\n", *(int*)QStack_Pop(stack));
}
printf("\n");

for(i=0; i<6; i++)
{
a[i] = i+10;

QStack_Push(stack, a+i);
}

while(QStack_Length(stack) > 0)
{
printf("Pop:  %d\n", *(int*)QStack_Pop(stack));
}

QStack_Destroy(stack);

return 0;
}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航