1使用两个栈实现一个队列 2 使用两个队列实现一个栈 3 判断入栈顺序的合法性

使用两个栈实现一个队列：

如图所示数据入栈，队列是队尾进数据，队头删数据，而在栈中，我们无法在对头删除数据，因此，需要把S1里的n-1个数据放到S2中，然后删除S1中的数据，在将S2中的数据放回到S1中。

 

stack.c

#include"stack.h"
void stackinit(stack *s)
{
	assert(s);
	s->_size = 0;
}

void stackpush(stack *s, DataType data)
{
	assert(s);
	if (s->_size == MAX_SZIE)
		return;
	s->_arr[s->_size] = data;
	s->_size += 1;
}

void stackpop(stack *s)
{
	assert(s);
	if (s->_size == 0)
		return;
	s->_size -= 1;
}
DataType stacktop(stack *s)
{
	assert(s);
	if (s->_size == 0)
		exit(0);
	return s->_arr[s->_size - 1];
}
void stackprint(stack *s)
{ 
	int i = 0;
	assert(s);
	if (s->_size == 0)
		return;
	for (i = 0;i < s->_size;i++)
	{
		printf("%d-> ",s->_arr[i]);
	}
	printf("\n");
}
//////////////////////////////////////
void queuestackinit(queuestack *s)
{
	assert(s);
	stackinit(&s->s1);
	stackinit(&s->s2);
}
void queuestackpop(queuestack *s)
{
	int i = 0;
	assert(s);
	while(s->s2._size)
	{
		stackpush(&s->s1,stacktop(&s->s2));
		stackpop(&s->s2);
	}
	while(s->s1._size > 1)
	{
	    stackpush(&s->s2,stacktop(&s->s1));
		stackpop(&s->s1);
	}
	printf("%d->",stacktop(&s->s1));
	stackpop(&s->s1);

}
void queuestackpush(queuestack *s, int data)
{
	assert(s);
	if (s->s1._size == MAX_SZIE)
		return;
	stackpush(&s->s1,data);
}

stack.h

#include<stdlib.h>
#include<assert.h>

#define MAX_SZIE 10

typedef int DataType;
typedef struct stack
{
	DataType  _arr[MAX_SZIE];
	int _size;
}stack;
typedef struct minstack
{
	struct stack s1;
	struct stack s2;
}queuestack;

void stackinit(stack *s);
void stackpush(stack *s, DataType data);
void stackpop(stack *s);
DataType stacktop(stack *s);
void stackprint(stack *s);
//////////////////////////////////////
void queuestackinit(queuestack *s);
void queuestackpop(queuestack *s);
void queuestackpush(queuestack *s, int data);

test.c

#include"stack.h"  
test()
{
	queuestack s;
	queuestackinit(&s);

	queuestackpush(&s, 1);
	queuestackpush(&s, 2);
	queuestackpush(&s, 3);
	queuestackpush(&s, 4);
	queuestackpush(&s, 5);
	queuestackpush(&s, 6);

	queuestackpop(&s);
	queuestackpop(&s);
	queuestackpop(&s);
	queuestackpop(&s);
	queuestackpop(&s);
	queuestackpop(&s);

}

int main()
{
	test();
	system("pause");
	return 0;
}

2:使用两个队列实现一个栈

H

#pragma once  

#include<stdio.h> 
#include<stdlib.h>
#include<assert.h>
#define MAX_QUEUE 100  

typedef int DataType;

typedef struct queue
{
	DataType _arr[MAX_QUEUE];
	int _front;
	int _rear;
}queue;
typedef struct stack
{
	struct queue q1;
	struct queue q2;
}stack;

void queue_init(queue *q);//初始化  

void queue_en(queue *q, DataType data);//入队列  

void queue_de(queue *q);//出队列  

int  queue_Empty(queue *q);//队列判空  

 get_head(queue *q);//获取队头元素  

 void queue_print(queue *q);

//////////////////////////////////////////////
void stackqueue2init(stack *q);
void stackqueue2push(stack *q,DataType data);
void stackqueue2pop(stack *q);
void stackqueue2top(stack *q);
int stackqueue2empty(stack *q);

C

#include"stackqueue2.h"  
void queue_init(queue *q)
{
	//构造一个空队列  
	q->_front = q->_rear = 0;
	printf("初始化已完成！\n");
}

void queue_en(queue *q, DataType data)
{
	if (q->_rear == MAX_QUEUE)
	{
		printf("队列已满！\n");
		return;
	}
	q->_arr[q->_rear] = data;


	q->_rear += 1;
}

void queue_de(queue *q)//出队列  
{

	if (!queue_Empty(q))
	{
		printf("队列为空！");
		return;
	}

	q->_front += 1;
}

int  queue_Empty(queue *q)
{
	if (q->_front == q->_rear)
	{
		return 0;
	}
	return 1;
}

int get_head(queue *q)//获取队头元素  
{
	if (!queue_Empty(q))
	{
		printf("队列为空");
		return;
	}
	return  q->_arr[q->_front];

}
void queue_print(queue *q)
{
	int i = 0;

	if (q->_front == q->_rear)
	{
		printf("队列为空！\n");
		return;
	}

	printf("开始打印：\n");
	for (i = q->_front;i<q->_rear;i++)
	{
		printf("%d ", q->_arr[i]);
	}

	printf("\n");
}


//////////////////////////////////////
void stackqueue2init(stack *q)
{
	assert(q);
	queue_init(&(q->q1));
	queue_init(&(q->q2));
}
void stackqueue2push(stack *q, DataType data)
{
	assert(q);
		queue_en(&(q->q1), data);
}
void stackqueue2pop(stack *q)
{
	assert(q);
	if (stackqueue2empty(q))
	{
		printf("队列为空!!!");
		return;
	}
	else 
	{
		if (q->q2._front  == q->q2._rear)
		{
			while (q->q1._front +1 != q->q1._rear)
			{
				queue_en(&q->q2,get_head(&q->q1));
				queue_de(&q->q1);
			}
			printf("%d->",get_head(&q->q1));
			queue_de(&q->q1);

		}
		else
		{
			while (q->q2._front + 1 != q->q2._rear)
			{
				queue_en(&q->q1, get_head(&q->q2));
				queue_de(&q->q2);
			}
			printf("%d->", get_head(&q->q2));
			queue_de(&q->q2);
		}
	}
}

int stackqueue2empty(stack *q)
{
	assert(q);
	if (queue_Empty(&q->q1) && queue_Empty(&q->q2))
	{
		return 1;
	}
	return 0;
}
void stackqueue2top(stack *q);
int main()
{
	stack q;
	stackqueue2init(&q);

	stackqueue2push(&q, 1);
	stackqueue2push(&q, 2);
	stackqueue2push(&q, 3);
	stackqueue2push(&q, 4);
	stackqueue2push(&q, 5);

	stackqueue2pop(&q);
	stackqueue2pop(&q);
	stackqueue2pop(&q);
	stackqueue2pop(&q);
	stackqueue2pop(&q);



	system("pause");
	return 0;
}

3 判断入栈顺序的合法性

h

void InOutisvalid(Stack *S,int *Inorder,int Insize,int  *Outorder,int Outsize);

c

void InOutisvalid(Stack *S,int *Inorder,int Insize,int *Outorder,int Outsize)
{
	int In = 0;
	int Out = 0;
	while (Out < Outsize)
	{
		while (StackEmpty(S) || StackTop(S) != Outorder[Out])
		{
			StackTop(S);
			printf("Out元素为：%d\n", Outorder[Out]);
			if ((In < Insize))
			{
				StackPush(S, Inorder[In++]);

			}
			else
			{
				printf("不合理!\n");
				return;
			}
		}
		    printf("此时栈顶元素为：%d\n", S->_arr[S->_top]);
			StackPop(S);
			Out += 1;
	
	}
	printf("合理！\n");
}

test

test()
{
	Stack S;
	StackInit(&S);
	int Inorder[] = {1,2,3,4,5,};
	int Outorder[] = {4,5,3,2,1};
	int Insize = sizeof(Inorder) / sizeof(Inorder[0]);
	int Outsize = sizeof(Outorder) / sizeof(Outorder[0]);
	InOutisvalid(&S,&Inorder,Insize,&Outorder, Outsize);
	
}
int main()
{
	test();
	system("pause");
}