栈与队列的性质互换

本期内容：栈，队列的定义性质，性质转换

认识栈

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
就像是向水杯里放入乒乓球，然后逐一取出来。

栈因为本身的结构，所以接口实现时就只有数据的插入（栈顶），删除（栈顶），栈顶元素的获取。对于栈来说栈内的数据容易被遍历数据，遍历时就比较耗时。所以决定了栈就是先进后出FILO

实现栈

头文件包含：

typedef int STDataType;
typedef struct Stack
{
    
    
	STDataType* _a;
	int _top; // 栈顶
	int _capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);

实现：

#include"SL.h"

// 初始化栈
void StackInit(Stack* ps)
{
    
    
	STDataType* new = (STDataType*)malloc(10*sizeof(STDataType));
	if (new == NULL)
	{
    
    
		perror("malloc fail");
	}
	ps->_a = new;
	ps->_capacity = 10;
	ps->_top = 0;//相当于顺序表size。有效个数
}

// 销毁栈
void StackDestroy(Stack* ps)
{
    
    
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}



// 入栈
void StackPush(Stack* ps, STDataType data)
{
    
    
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
    
    
		STDataType* tmp = (STDataType*)realloc(ps->_a, sizeof(STDataType) * 2 * ps->_capacity);
		if (tmp == NULL)
		{
    
    
			perror("realloc fail");
		}
		ps->_a = tmp;
		ps->_capacity *= 2;
	}
	ps->_a[ps->_top] = data;//数据入栈
	ps->_top++;
}

// 出栈
void StackPop(Stack* ps)
{
    
    
	assert(ps);
	assert(ps->_top > 0);

	ps->_a[ps->_top--];
	/*ps->_top--;*/
}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
    
    
	assert(ps);
	assert(ps->_top > 0);

	return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
    
    
	assert(ps);

	return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(Stack* ps)
{
    
    
	assert(ps);
	
	return ps->_top==0;
}

队列

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

结构决定算法，所以队列就是先进先出FIFO。实现时选择链表结构实现。链表可以实现对于头部删除和尾部插入效率十分的高。数组实现需要挪动数据时间复杂度O（n）。

实现

// 初始化队列
void QueueInit(Queue* q)
{
    
    
	assert(q);

	q->size = 0;
	q->_phead = NULL;
	q->_tail = NULL;
}
// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
    
    
	assert(q);
	QNode* node = (QNode*)malloc(sizeof(QNode));
	if (node == NULL)
	{
    
    
		perror("malloc fail");
	}
	node->_data = data;
	node->_pNext = NULL;


	if (q->_tail == NULL)
	{
    
    
		q->_phead=q->_tail =  node;
	}
	else
	{
    
    
		q->_tail->_pNext = node;
		 q->_tail=node;
	}
	q->size++;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
bool QueueEmpty(Queue* q)
{
    
    
	assert(q);

	return q->_phead && q->_tail;
}

// 队头出队列
void QueuePop(Queue* q)
{
    
    
	assert(q);
	assert(QueueEmpty(q));

	if (q->_phead->_pNext == NULL)
	{
    
    
		free(q->_phead);
		q->_phead = q->_tail = NULL;
	}
	else
	{
    
    
		QNode* del = q->_phead;
		q->_phead = q->_phead->_pNext;
		free(del);
	}
	q->size--;
}
// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
    
    
	assert(q);

	return q->_phead->_data;
}
// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
    
    
	assert(q);

	return q->_tail->_data;

}
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
    
    
	assert(q);

	return q->size;
}
// 销毁队列
void QueueDestroy(Queue* q)
{
    
    
	assert(q);

	QNode* cur = q->_phead;
	while (cur)
	{
    
    
		QNode* del = cur;
		cur = cur->_pNext;
		free(del);
	}
	q->_phead = NULL;
	q->_tail = NULL;
	q->size = 0;
}

性质转换

用队列实现栈

思路：
对于使用队列的来说先进先出，栈是后进先出。这里实现时就是对于数据的输出顺序做调整。按照题目要求使用数定义栈，
1、push让一个队列不为空，一个队列始终为空。空队列用来存储push的值。不为空的用来模拟栈。
2、对于pop时有着一个队列没有pop空，这时就需要做一个假设，假设q1为空，q2不为空。判断假设是否正确，不正确就更换。
3、对于不为空的队列连续push前面n-1个数值到空队列中。不为空的队列最后一个就是栈顶元素。（比较灵活的一步）

代码参考;

typedef struct {
    
    
    Queue Inqueue;
    Queue Outqueue;
} MyStack;

MyStack* myStackCreate() {
    
    
	MyStack* obj=(MyStack*)malloc(sizeof(MyStack));
	QueueInit(&obj->Inqueue);
	QueueInit(&obj->Outqueue);

	return obj;
}

void myStackPush(MyStack* obj, int x) {
    
    

   if(!QueueEmpty(&obj->Inqueue))
	 {
    
    
		 QueuePush(&obj->Inqueue,x);
	 }
	 else{
    
    
		 QueuePush(&obj->Outqueue,x);
	 }
}

int myStackPop(MyStack* obj) {
    
    

    Queue* EmptyQ=&obj->Inqueue;
		Queue* NoemptyQ=&obj->Outqueue;
		if(!QueueEmpty(&obj->Inqueue))
		{
    
    
			EmptyQ=&obj->Outqueue;
			NoemptyQ=&obj->Inqueue;
		}

		while(QueueSize(NoemptyQ)>1)
		{
    
    
			QueuePush(EmptyQ,QueueFront(NoemptyQ));
			QueuePop(NoemptyQ);
		}

		int top=QueueFront(NoemptyQ);
		QueuePop(NoemptyQ);

		return top;
}

int myStackTop(MyStack* obj) {
    
    
   if(!QueueEmpty(&obj->Inqueue))
	 {
    
    
		 return QueueBack(&obj->Inqueue);
	 }
	 else{
    
    
		 return QueueBack(&obj->Outqueue);
	 }
}

bool myStackEmpty(MyStack* obj) {
    
    

    return (QueueEmpty(&obj->Inqueue)) && (QueueEmpty(&obj->Outqueue));

}

void myStackFree(MyStack* obj) {
    
    

	QueueDestroy(&obj->Inqueue);
	QueueDestroy(&obj->Outqueue);
	free(obj);

}

栈实现队列

思路：
通过创建2个栈来对于数据进行数据倒序。需要确定栈的使用。push栈，pop栈需要明确，方便后面进行数据转换使用，
1、对于一个栈用来push，一个栈来使用pop。对于push栈来说始终对于数据插入，一个栈模拟出数据。
2、对于pop栈的栈顶元素，就是队列数据出栈。

typedef struct {
    
    
    Stack ist;
    Stack ost;

} MyQueue;

bool myQueueEmpty(MyQueue* obj);
MyQueue* myQueueCreate() {
    
    
        MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
        StackInit(&obj->ist);
        StackInit(&obj->ost);

        return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    
    
	assert(obj);
    StackPush(&obj->ist,x);
}

int myQueuePop(MyQueue* obj) {
    
    

   assert(obj);
	 assert(!myQueueEmpty(obj));

	 int top=myQueuePeek(obj);
	 StackPop(&obj->ost);

    return top;
}

int myQueuePeek(MyQueue* obj) {
    
    
 assert(obj);
	 assert(!myQueueEmpty(obj));
//倒数据
	 if(StackEmpty(&obj->ost))
	 {
    
    
		 while(!StackEmpty(&obj->ist))
		 {
    
    
			 StackPush(&obj->ost,StackTop(&obj->ist));
			 StackPop(&obj->ist);
		 }
	 }
	 return StackTop(&obj->ost);
}

bool myQueueEmpty(MyQueue* obj) {
    
    
	assert(obj);
    return StackEmpty(&obj->ist)&&StackEmpty(&obj->ost);
}

void myQueueFree(MyQueue* obj) {
    
    
	assert(obj);
    StackDestroy(&obj->ist);
    StackDestroy(&obj->ost);
    free(obj);
}

上面就是只栈与队列的基本性质定义，还有相互转换使用各自的特性实现。