顺序栈S中有2n个元素，从栈顶到栈底的元素依次为a2n、a2n-1、…、a1。试设计一个算法：通过一个循环队列重新排列该栈中的元素，使得从栈顶到栈底的元素先偶数，后奇数

#include<stdio.h>
#include<math.h>
#define STACK_INIT_SIZE 100
#define QUEUE_MAX_SIZE  100
#define STACK_INCREMENT 10
using namespace std;
typedef struct Stack  //结构体定义
{
	int *elem;          //数据域
	int top;    //顺序栈栈顶
	int stacksize;     //顺序栈当前长度
}Stack;
typedef struct Sqqueue   //循环队列结构体定义
{
	int  *data;
	int front;
	int rear;
}Sqqueue;
//公共函数声明
void Error(char *s);        //错误处理函数
void Reset();               //重置函数
//顺序栈函数声明
Stack Creat_Stack();        //若干个元素的顺序栈
void Destroy_Stack(Stack & l); //销毁顺序栈	
void Push_Stack(Stack &L, int e);  //压栈操作函数
int  Pop_Stack(Stack &L, int e);   //出栈操作函数
void Increment_Stack(Stack & l);   //增加顺序栈空间函数
void Print_Stack(Stack & l);       //输出顺序栈元素函数、
//循环队列函数声明                
void Init_Sqqueue(Sqqueue &q);                  //初始化循环队列
void Destroy_Sqqueue(Sqqueue &q);				//销毁循环队列函数		
void En_Sqqueue(Sqqueue &q, int e);				//入队操作
int De_Sqqueue(Sqqueue &q, int e);				//出队操作
void Print_Sqqueue(Sqqueue &q);					//以此输出循环队列的值
//顺序栈函数定义
Stack Creat_Stack()
{
	int length = 0;
	int data = 0;
	Stack l;
	l.elem = new int[STACK_INIT_SIZE];
	if (!l.elem)
		Error("内存申请失败！");
	l.top = -1;
	l.stacksize = STACK_INIT_SIZE;
	cout << "请输入顺序栈长度：";
	cin >> length;
	cout << "请输入顺序栈元素内容:" << endl;
	for (int i = 0; i < length; i++)
	{
		cin >> data;
		l.elem[i] = data; //这一步是重点
		l.top++;
	}
	cout << "顺序栈创建成功！" << endl;
	return l;
}
void Destroy_Stack(Stack &l)
{
	delete[] l.elem;
	l.top = -1;
	l.stacksize = 0;
	cout << "该顺序栈销毁成功！" << endl;
}
void Increment_Stack(Stack &l)
{
	int *newstack = new int[l.stacksize + STACK_INCREMENT];
	if (!newstack)
		Error("存储分配失败！");
	for (int i = 0; i < l.top; i++)
	{
		newstack[i] = l.elem[i];
	}
	l.elem = newstack;
	delete[] l.elem;
	l.stacksize += STACK_INCREMENT;
}
void Push_Stack(Stack &l, int e)
{
	if (l.top == (l.stacksize - 1))
		Increment_Stack(l);
	l.elem[++l.top] = e;
}
int  Pop_Stack(Stack &l, int e)
{
	if (l.top == -1)
		Error("该顺序栈为空栈！");
	return e = l.elem[l.top--];

}
void Print_Stack(Stack &l)
{
	cout << "该顺序栈的元素是：" << endl;
	for (int i = l.top; i > -1; i--)
	{
		cout << l.elem[i] << " ";
	}
	cout << endl;
}
//循环队列函数定义
void Init_Sqqueue(Sqqueue &q)
{
	q.data = new int[QUEUE_MAX_SIZE];
	if (!q.data)
		Error("存储分配失败!");
	q.front = q.rear = 0;
}
void Destroy_Sqqueue(Sqqueue &q)
{
	delete[] q.data;
	q.front = q.rear = 0;
	cout << "该循环队列销毁成功!";
}
void En_Sqqueue(Sqqueue &q, int e)
{
	if (((q.rear + 1) % QUEUE_MAX_SIZE) == q.front)
		Error("该循环队列已满！");
	q.data[q.rear] = e;
	q.rear = (q.rear + 1) % QUEUE_MAX_SIZE;
}
int  De_Sqqueue(Sqqueue &q, int e)
{
	if (q.front == q.rear)
		Error("该循环队列为空队列！");
	e = q.data[q.front];
	q.front = (q.front + 1) % QUEUE_MAX_SIZE;
	return e;
}
void Print_Sqqueue(Sqqueue &q)
{
	cout << "该循环队列的元素是：";
	while (q.front != q.rear)
	{
		cout << q.data[q.front] << " ";
		q.front = (q.front + 1) % QUEUE_MAX_SIZE;
	}
	cout << endl;
}
//公共函数定义
void Error(char *s)
{
	cout << s << endl;
	exit(1);
}
void Reset() 
{
	Stack s;
	Sqqueue q;
	int e = 0;
	int i = 0;
	int n = 10;//此处可以修改，这里只是简单操作而已，且应该与顺序栈的长度一致
	int temp = 0;
	Init_Sqqueue(q);
	s = Creat_Stack();
	for (i = 0; i < n; i++)
	{
		temp = Pop_Stack(s, e);
		En_Sqqueue(q, temp);  //将出栈后的元素以此入队
	}
	//Print_Sqqueue(q);
	for (i = 0; i < n; i++)
	{
		temp=De_Sqqueue(q, e);   
		if (temp % 2 == 0)         //判断是否为偶数
			En_Sqqueue(q, temp);   //若是偶数，再次入队
		else
			Push_Stack(s, temp);   //若是奇数，再次入栈
	}
	for (i = 0; i < n / 2; i++)
	{
		En_Sqqueue(q, Pop_Stack(s, e));//将奇数出栈入队,现在队列中有全部元素
	}
	for (i = 0; i < n / 2; i++)
	{
		Push_Stack(s, De_Sqqueue(q, e));//将偶数出队入栈，此时队列中只剩奇数
	}
	for (i = 0; i < n / 2; i++)
	{
		En_Sqqueue(q, Pop_Stack(s, e));//将偶数出栈入队，此时队列中有所有元素
	}
	for (i = 0; i < n; i++)
	{
		Push_Stack(s, De_Sqqueue(q, e));//将所有元素出队入栈，此时队列中有所有元素
	}
	Print_Stack(s);
}
int main()
{
	Reset();
	return 0;
}