栈实现队列、队列实现栈

       栈遵循“后进先出”的规则、队列遵循“先进先出”的规则、如何使他们互相实现对方的功能、以下给出具体的图解与代码

       栈实现队列

• 图解思路

• 代码实现

首先，实现一个栈的入栈、出栈等基本操作

typedef int DataType;
typedef struct  Stack {
	DataType*  array;
	int capacity;   //最大容量
	int size;      //代表栈内有效元素数量,也代表栈顶指针
}Stack;

//检测容量,动态扩容
void CheckCapacity(Stack* ps) {
	assert(ps);
	if (ps->capacity == ps->size) {
		ps->capacity += 3;
		ps->array = (DataType*)realloc(ps->array, sizeof(DataType)* ps->capacity);
	}
}

//初始化
void StackInit(Stack* ps) {
	assert(ps);
	ps->array = ( DataType* ) malloc(sizeof(DataType) * 3);
	if (ps->array == NULL) {
		assert(0);
		return;
	}
	ps->capacity = 3;
	ps->size = 0;
}

//压栈
void StackPush(Stack* ps, DataType data) {
	//检测空间剩余
	CheckCapacity(ps);
	ps->array[ps->size++] = data;
}


//出栈
int StackPop(Stack* ps) {
	assert(ps);
	if (StackEmpty(ps))
		return;
    int ret = StackTopElem(ps);
	ps->size -= 1;
	return ret;
}

//获取栈顶元素
int StackTopElem(Stack* ps) {
	assert(ps);
	return ps->array[ps->size-1];
}

//栈判空
int StackEmpty(Stack* ps) {
	assert(ps);
	if (0 == ps->size)
		return 1;
	return 0;
}

//销毁
void StackDestroy(Stack* ps) {
	assert(ps);
	if (ps->array) {
		free(ps->array);
		ps->capacity = 0;
		ps->size = 0;
	}
}

创建队列结构，包含两个栈

typedef struct {
    Stack s1;
    Stack s2;
} MyQueue;

//申请空间，初始化队中的栈
MyQueue* myQueueCreate() {
	MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
	if (q == NULL) {
		assert(0);
		return;
	}
	StackInit(&q->s1);
    StackInit(&q->s2);
    return q;
}

//入队列
void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->s1,x); 
}

//出队列
int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->s2)){
        while(StackEmpty(&obj->s1)!=1){
            StackPush(&obj->s2,StackPop(&obj->s1));
        }
    }
    int ret = StackPop(&obj->s2);
    return ret;
}

//队头元素
int myQueuePeek(MyQueue* obj) {
     if(StackEmpty(&obj->s2)){
        while(StackEmpty(&obj->s1)!=1){
        StackPush(&obj->s2,StackPop(&obj->s1));
        }
    }
    return StackTopElem(&obj->s2);
}

//队列判空
bool myQueueEmpty(MyQueue* obj) {
    if(StackEmpty(&obj->s1) && StackEmpty(&obj->s2))
        return true;
    return false;
}

//销毁队列
void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->s2);
    StackDestroy(&obj->s1);
    free(obj);
}

以上我们用两个栈来实现队列结构的特性和功能。

       队列实现栈

• 图解思路
  

• 代码实现

首先，实现一个队列的入队、出队等基本操作

typedef int DataType;
typedef struct QNode
{
	struct QNode* next;
	DataType data;
}QNode;

typedef struct Queue
{
	QNode*  front; // 指向队头元素 
	QNode*  rear; // 指向队尾元素 
}Queue;

//新建节点
QNode* CreatNewNode(DataType data) {
	QNode* NewNode = (QNode*)malloc(sizeof(QNode));
	if (NewNode == NULL){
		assert(0);
		return NULL;
	}
	NewNode->next = NULL;
	NewNode->data = data;
	return NewNode;
}

//初始化
void QueueInit(Queue* q) {
	assert(q);
	q->front = q->rear = NULL;
}

//入队
void QueuePush(Queue* q, DataType data) {
	assert(q);
	QNode* NewNode = CreatNewNode(data);
	if (QueueEmpty(q)) {
		q->front = q->rear = NewNode;
	}
	else {
		q->rear->next = NewNode;
		q->rear = NewNode;
	}
}

//出队
int QueuePop(Queue* q) {
	assert(q);
	if (QueueEmpty(q)) {
		return ;
	}
	else {
		QNode* Qtmp = q->front;
		if (Qtmp->next == NULL) {
			q->front = q->rear = NULL;
		}
		q->front = Qtmp->next;
        return Qtmp->data;
	}
}

//队头元素
DataType QueueFront(Queue* q) {
	assert(q);
	if (QueueEmpty(q)) {
		return;
	}
	else {
		return q->front->data;
	}
}

//队尾元素
DataType QueueRear(Queue* q) {
	assert(q);
	if (QueueEmpty(q)) {
		return -1;
	}
	else {
		return q->rear->data;
	}
}

//元素个数
int QueueSize(Queue* q) {
	assert(q);
	int count = 0;
	QNode* QCur = q->front;
	while (QCur!= NULL) {
		count++;
		QCur = QCur->next;
	}
	return count;
}

//队判空
int QueueEmpty(Queue* q) {
	assert(q);
	if (q->front == NULL)
		return 1;
	return 0;
}

//队销毁
void QueueDestroy(Queue* q) {
	QNode* QCur = q->front;
	while (QCur!=NULL) {
		q->front = QCur->next;
		free(QCur);
		QCur = q->front;
	}
	q->front = q->rear = NULL;
}

创建栈结构，包含两个队列

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

//申请空间,初始化两个队列
MyStack* myStackCreate() {
    MyStack* S=(MyStack*)malloc(sizeof(MyStack));
    if(S == NULL){
        return NULL;
    }
    QueueInit(&S->q1);
    QueueInit(&S->q2);
    return S;
}

//入栈
void myStackPush(MyStack* obj, int x) {
    assert(obj);
    if(QueueEmpty(&obj->q2)){
        QueuePush(&obj->q1,x);
    }
    else if(QueueEmpty(&obj->q1)){
        QueuePush(&obj->q2,x);
    }
}

//出栈
int myStackPop(MyStack* obj) {
    assert(obj);
    if(!QueueEmpty(&obj->q1)){
        int size=QueueSize(&obj->q1);
        while(size>1){
            QueuePush(&obj->q2,QueuePop(&obj->q1));
            size--;
        }
        int ret=QueuePop(&obj->q1);
        return ret;
    }
   else{
        int size=QueueSize(&obj->q2);
        while(size>1){
            QueuePush(&obj->q1,QueuePop(&obj->q2));
            size--;
        }
    int ret=QueuePop(&obj->q2);
    return ret;
    }
}

//栈顶元素
int myStackTop(MyStack* obj) {
    assert(obj);
    if(QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2))
        return ;
    int ret=0;
    if(QueueEmpty(&obj->q1)){
        ret=QueueRear(&obj->q2);
    }
    else{
        ret=QueueRear(&obj->q1);
    }
    return ret;
}

//栈判空
bool myStackEmpty(MyStack* obj) {
    if(QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2))
        return true;
    return false;
}

//栈销毁
void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

以上我们用两个队列来实现栈结构的特性和功能