队列实现:

结构体定义:

用单链表实现队列,队列要求元素先进先出

定义节点结构体QNode

定义队列,包括指向队首的指针和指向队尾的指针,int size用于记录当前队列元素个数

typedef struct QNode
{
	struct QNode* next;
	Type data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;//记录当前队列元素个数
} Queue;

抽象出来的结构如下:

 

 队列初始化:void QueueInit(Queue* pq);

主函数栈区开辟Queue 结构体后,Queue内包括一个队首指针和一个队尾指针.

初始化的功能是将front和rear置空:

void QueueInit(Queue* pq)
{
	pq->head= NULL;
	pq->tail = NULL;
	pq->size = 0;


}

入队:void QueuePush(Queue* pq,Type x);

入队就是实现尾插,因为没有哨兵位的头节点,所以需要分情况处理:

1.当head==NULL,直接将新节点赋值给front

2.当head不为空,tail->next=newnode,

void QueuePush(Queue* pq,Type x)
{
	assert(pq);
	
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("error ::");
		return;
	}
	newnode->next = NULL;
	newnode->data = x;

	//考虑队列为空,但是队尾指针不为空的情况
	if (pq->head == NULL)
	{
		assert(pq->tail == NULL);
		pq->head = pq->tail = newnode;
		pq->size++;

		return;
	}
	
	pq->tail->next = newnode;
	pq->tail = newnode;
	newnode = NULL;
	pq->size++;

	
}

出列:void QueuePop(Queue* pq);

相当于单链表中的头删,依旧是两种情况处理:

1.队列中只有一个节点时,head==tail

2.队列中有多个节点

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	
	
	if (pq->head == pq->tail)
	{
		
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
		pq->size--;
		return;
	}
	QNode* del = pq->head;
	pq->head = pq->head->next;
	free(del);
	pq->size--;
	del = NULL;

}

尤其注意在出队列的时候,当队列中仅剩一个节点的时候,不要忽略队tail指针的处理,仅free(head),但是tail依旧指向刚被释放的head指向的空间

返回队列大小:int QueueSize(Queue* pq);

设计Queue节点时,size 成员记录当前队列的大小,直接返回:

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;

}

判断队列是否为空:bool Empty(Queue* pq);

看Queue结构内的size成员是否为0:

//判断队列是否为空
bool Empty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

获取队首元素:

//获取队首元素
Type  Queuefront(Queue* pq)
{
	return pq->head->data;

}

获取队尾元素:

Type Queueback(Queue* pq)
{
	return pq->tail->data;
}

OJ:用两个队列实现栈

思路:

        队列是先进先出,栈是后进先出.

        用队列实现栈,意味着最后入队的元素要最先出队列,那么最后一个元素一定要来到队首,从队首位置出,才不破坏队列的结构

        所以另一个队列的作用就显示出来了,当我们要出元素时,将队列1中前n-1个元素放到队列2,那么队列1的最后一个元素就可以正常出队,即实现了后进先出.

 

当要再入元素的时候:

 

 代码:

typedef struct {
    Queue Q1;
    Queue Q2;


} MyStack;


MyStack* myStackCreate() {
    MyStack* pst;
    MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
    if(pst==NULL)
    {
        perror("Stack malloc error");
    }
    QueueInit(&pst->Q1);
    QueueInit(&pst->Q2);
    return pst;

}

void myStackPush(MyStack* obj, int x) {
    if(!Empty(&obj->Q1))
    {
        QueuePush(&obj->Q1,x);
    }
    else
    {
        QueuePush(&obj->Q1,x);
    }
    
 

}

int myStackPop(MyStack* obj) {
    Queue* emptyQ=obj->Q1;
    Queue* noempty=obj->Q2;
    if(!Empty(empty))
    {
        emptyQ=obj->Q2;
        noempty=obj->Q1;

    }
    while(noempty->size>1)
    {
        QueuePush(empty,Queuefront(noempty));
        QueuePop(noempty);
    }
    //此时noempty中还剩下一个元素
    int top=Queuefront(noempty);
    QueuePop(noempty);
    return top;


}

int myStackTop(MyStack* obj) {
    //取栈顶元素
    //直接返回队列的最后一个元素
    if(!Empty(obj->Q1))
    {
        return Queueback(obj->Q1);
    }
    else

    {
        return Queueback(obj->Q2);
    }

}

bool myStackEmpty(MyStack* obj) {

}

void myStackFree(MyStack* obj) {

}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

结构如下: