☀☀☀☀☀☀☀有关栈和队列应用的oj题讲解☼☼☼☼☼☼☼

准备好了么

一·用两个队列实现栈：

1·思路：

2·画图理解：

3·代码解答：

二·用两个栈实现队列：

1·思路：

2·画图理解：

3·代码解答：

三·设计循环队列：

1·思路：

2·画图理解：

3·代码解答：

一·用两个队列实现栈：

源：oj链接：. - 力扣（LeetCode）

1·思路：

我们首先调用创建好的队列代码，然后假设令这两个队列作为一个栈，由于我们画图可以得出一个结论：

①当有两个空队列的时候，我们push时随便push，一直往不为空的队列里面push。

②当我们要移除并返回栈顶元素的时候，我们要把不为空的队列里n-1个元素push到另一个空的队列里面，最后得到将要pop与return的元素。

③只返回栈顶元素只需要返回不为空队列的尾指针指向的元素即可。

④判空的话，就是两个队列都为空才行。

2·画图理解：

3·代码解答：

typedef int qdatatype;
typedef struct Qnode {
	struct Qnode* next;
	qdatatype data;
}Qnode;
typedef struct queue {
	int size;
	Qnode* head;
	Qnode* tail;
}queue;

void Queueinit(queue* p) {
	assert(p);

	p->head =p->tail = NULL;
	p->size = 0;
}


void Queuedestroy(queue* p) {
	assert(p);
	Qnode* cur = p->head;
	while (cur) {
		Qnode* next = cur->next;
		free(cur);
		cur = next;
	}
	p->size = 0;
	p->tail = p->head = NULL;
}


void Queuebackpush(queue* p, qdatatype x) {
	assert(p);
	Qnode* newnode = (Qnode*)malloc(sizeof(Qnode));
	if (newnode == NULL) {
		perror(malloc);
		return;
	}
	newnode->next = NULL;
	newnode->data = x;
	if (p->tail == NULL) {
		p->head = p->tail = newnode;
	}
	else {
		p->tail->next = newnode;
		p->tail = newnode;
	}
	p->size++;


}

void Queuefrontpop(queue* p) {
	assert(p);
	assert(p->size > 0);
	if (p->head->next == NULL) {
		free(p->head);
		p->head = p->tail = NULL;
	}
	else {
		Qnode* next = p->head->next;
		free(p->head);
		p->head = next;
	}
	p->size--;
}


qdatatype Queuefrontdata(queue* p) {
	assert(p);
	assert(p->size > 0);
	return p->head->data;
}


qdatatype Queuebackdata(queue* p) {
	assert(p);
	assert(p->size > 0);
	return p->tail->data;
}


int Queuesize(queue* p) {
	assert(p);
	return p->size;
}


bool QueueEmpty(queue* p) {
	assert(p);
	return p->size == 0;
}


//以上是引用的队列的创建

typedef struct {
    queue p1;
    queue p2;

} MyStack;//这里定义了一个结构体类型：我的栈：里面放了两个队列结构体类型的变量


MyStack* myStackCreate() {
    MyStack*pst=(MyStack*)malloc(sizeof(MyStack));
     Queueinit(&(pst->p1));
     Queueinit(&(pst->p2));
     return pst;

}//在这里将MyStack结构体里面的两个队列初始化，并得到MyStack类型的指针

void myStackPush(MyStack* obj, int x) {
   if( !QueueEmpty(&(obj->p1))){
    Queuebackpush(&(obj->p1),x);
   }
   else{
    Queuebackpush(&(obj->p2),x);

   }

//这里我们在两个队列里面插入数据，故由于让看起来像栈的形式，我们就找有数据的队列插入新的数据即
//找不为空的队列插入


}

int myStackPop(MyStack* obj) {
    //这里我们用假设法来得到空与非空队列
    queue*empty=&(obj->p1);
    queue*noempty=&(obj->p2);
    if(!QueueEmpty(&(obj->p1))){
        //如果假设不成立执行下面
        noempty=&(obj->p1);
        empty=&(obj->p2);
    }
    //以上操作我们就可以得到noempty empty 分别为空与非空的队列
    while( Queuesize(noempty)>1){
        Queuebackpush(empty,Queuefrontdata(noempty));
        Queuefrontpop(noempty);
    }
    //下面防止找不到要得到的栈顶元素，我们在pop之前要先保存一下
    int data=Queuefrontdata(noempty);
    Queuefrontpop(noempty);
    return data;

}//首先我们要找到空的队列，然后把非空队列获得头部元素进行插到原来空的队列里，插入n-1个

int myStackTop(MyStack* obj) {
    if( !QueueEmpty(&(obj->p1))){
    return Queuebackdata(&(obj->p1));
   
   }
   else{
    return Queuebackdata(&(obj->p2));
    

   }
   //这里返回栈顶元素即就是我们不为空的队列的队尾元素

    
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&(obj->p1))&&QueueEmpty(&(obj->p2));
}

void myStackFree(MyStack* obj) {
     Queuedestroy(&(obj->p1));
     Queuedestroy(&(obj->p2));
     free(obj);
     obj=NULL;
//这里由于我们在 MyStack里开辟了两个队列的链表类型空间故需要先释放掉，
//再释放obj

}

测试：


int main()
{
    MyStack* st = myStackCreate();
    myStackPush(st, 1);
    myStackPush(st, 2);

    int ret = myStackTop(st);

    printf("%d",ret);
    mystackFree(st);
    return 0;
}

二·用两个栈实现队列：

源：oj链接：. - 力扣（LeetCode）

1·思路：

这里首先建立两个栈作为MyQueue，大致思路和两个队列实现栈相差不大，这里只不过是调用的事先创建的队列改成栈了，此外再删去元素的时候会多排序一次。

①push：还是找空的栈然后，依次入栈

②pop：类似于上面的实现，但是当我们把n-1个元素放到另一个空栈里面顺序与原来是相反的故需要颠倒一下，此时就要再入一次栈入到原栈里，（先保存再返回，再删除）。

③peek：由于我每次使用函数的时候，这两个栈必然有一个空有一个非空，只需要返回非空栈的下标为0的元素即可。

④empty：这里判空也是两个均为空。

2·画图理解：

3·代码解答：

typedef int typedata;
typedef struct stack {
	typedata* a;
	int top;
	int capacity;
 } ST;

void STinit(ST* p) {
	assert(p);
	p->a = NULL;
	p->capacity = p->top = 0;
}
void STpush(ST* p,typedata x) {
	assert(p);
	//扩容
	if (p->top == p->capacity) {
		int newcapacity = p->capacity == 0 ? 4 : (p->capacity) * 2;
		typedata* tmp = (typedata*)realloc(p->a, sizeof(typedata)*newcapacity);
		if (tmp == NULL) {
			perror("realloc");
			return;
		}
		p->a = tmp;
		p->capacity = newcapacity;

	}
	p->a[p->top] = x;
	p->top++;
}
void STpop(ST* p) {
	assert(p);
	assert(p->top);
	p->top--;


}

typedata STTop(ST* p) {
	assert(p);
	assert(p->top);
	return p->a[p->top - 1];

}
bool STempty(ST* p) {
	assert(p);
	return p->top == 0;
}
int STsize(ST* p) {
	assert(p);
	return p->top;
}
void STdestroy(ST* p) {
	assert(p);
	free(p->a);
	p->a = NULL;
	p->capacity = p->top = 0;
}

//以上是对栈的实现

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


MyQueue* myQueueCreate() {
    MyQueue* q=(MyQueue* )malloc(sizeof(MyQueue));
    STinit(&(q->s1));
    STinit(&(q->s2));
    return q;
//在MyQueue内开辟两个栈的空间

}

void myQueuePush(MyQueue* obj, int x) {
    if(!STempty(&(obj->s1))){
        STpush(&(obj->s1),x);
    }
    else{
        STpush(&(obj->s2),x);
         
    }//这里也是找到非空栈进行插入数据
}

int myQueuePop(MyQueue* obj) {
    ST*empty=&(obj->s1);
    ST*noempty=&(obj->s2);
    if(!STempty(&(obj->s1))){
        noempty=&(obj->s1);
        empty=&(obj->s2);
    }
    //通过假设法得到真实的非空与空的栈
    while(STsize(noempty)>1){
        STpush(empty,STTop(noempty));
         STpop(noempty);
        
    }
    //首先第一个循环是得到n-1个数据到原来空的栈里面，但是顺序是反的

    int data=STTop(noempty);
    STpop(noempty);
    //在这里保存队列即栈的第一个元素，并把它pop
    while(STsize(empty)>0){
         STpush(noempty,STTop(empty));
         STpop(empty);

    }
    //通过再一个循环把它重新插入到原来的栈里，顺序恢复

    return data;

}

int myQueuePeek(MyQueue* obj) {
    if(!STempty(&(obj->s1))){
       return obj->s1.a[0];
    }
    else{
        return  obj->s2.a[0];
    }
}
//直接返回栈的首元素即队首元素
bool myQueueEmpty(MyQueue* obj) {
    return STempty(&(obj->s1))&&STempty(&(obj->s2));
}

void myQueueFree(MyQueue* obj) {
    STdestroy(&(obj->s1));
    STdestroy(&(obj->s2));
    free(obj);
    obj=NULL;

}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

测试：

int main() {
    MyQueue* m = myQueueCreate();
    myQueuePush(m, 1);
    myQueuePush(m, 2);
    myQueuePush(m, 3);
    int ret = myQueuePop(m);
    printf("%d ", ret);
    int n=myQueuePeek(m);
    printf("%d ", n);


    return 0;
}

三·设计循环队列：

源：oj链接：. - 力扣（LeetCode）

1·思路：

设计循环队列，首先把它设计成一个数组的形式来循环利用，这里会涉及到判空与判满如何进行，

那么我们有两种方法解决，一个是进出队列用size记录，一个是额外多开辟一个空间，，我们选择用后者。比如设置长度为k，那么就要开辟k+1个空间。而多出来的空间我们不放数据用tail指向这个空的空间。（下面的head与tail实则是下标，把它假想为指针）

①MyCircularQueue：创建一个结构体存放队列要开辟的长度k，头尾指针以及int类型的指针a。

②myCircularQueueFront：找头，可以直接对a[head]去访问。

③myCircularQueueRear：访问尾指针前一个数据的话由于可能会存在tail为0，那么上一个就是-1，明显是不可能的，故需要转化，可以把它tail-1直接变成k，也可以tail-1后＋（k+1）%(k+1).

④myCircularQueueEnQueue:插入数据先判是否full，没有的话，就放入tail++，而可能存在为k+1.那么就把它变为0，或者直接（++tail）%（k+1）。

⑤ myCircularQueueDeQueue：这里我们画图可以发现删除数据只需要head++，而tail不用变化，但是head++，当过界时候把它变为0。

⑥myCircularQueueIsEmpty：头尾指针指向同一个处，即head==tail。

⑦myCircularQueueIsFull：画图可以知道每每当填满数据的时候tail+1==head（不包括越界改变的情况），故我们还是可以在tail到k+1，把它变为0，看是否与head相同，也可以（tail+1）%（k+1）看是否==head。

2·画图理解：

3·代码解答：


typedef struct {
    int head;
    int tail;
    int k;//要开辟的队列长度
     int *a;

} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    if(k<0){
        return NULL;
    }
    MyCircularQueue*q=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    int *m=(int*)malloc(sizeof(int)*(k+1));
    q->head=q->tail=0;
    q->a=m;
    q->k = k;//将结构体里的k初始化为队列长度k
    return q;


}
bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);//这里由于提前调用未定义的函数故需要在前面声明

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj)){
        return false;
    }
    else{
        // obj->a[obj->tail]=value;
        // obj->tail++;
        //  if(obj->tail==obj->k+1){
        // obj->tail=0;//这里有一个情况当tail+1到达数组超过数组最大额度就变为0
         obj->a[obj->tail]=value;
         obj->tail++;
         obj->tail%=obj->k+1;//这里取模可以简化上面的判断
    

   

  }
  return true;
}


bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj)){
        return false;
    }
    obj->head++;
    // obj->a[obj->tail++];
    // if(obj->tail==obj->k+1){
    //     obj->tail=0;
    // }
     if(obj->head==obj->k+1){
        obj->head=0;
    }
    return true;
    //这里我们要删出队列的第一个元素，那么只需要head++（这里也要考虑越界变0），然后tail不变即可




}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj)){
        return -1;
    }
    return obj->a[obj->head];
    
}

int myCircularQueueRear(MyCircularQueue* obj) {
     if(myCircularQueueIsEmpty(obj)){
        return -1;
    }
//     if(obj->tail==0){
//      return obj->a[obj->k];
//     }
//   else{
//     return obj->a[obj->tail-1];
//   }
  //这里是返回tail的上一个数据，故可能会出现tail为零那么tail-1=-1；实际为k
  //简化：
  
    return obj->a[(obj->tail-1+(obj->k+1))%(obj->k+1)];
  
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
     if(obj->head==obj->tail){
        return true;
    }
    else{
        return false; 
    }
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    // if(obj->tail==obj->k&&obj->head==0){
    //     return true;
    // }
    // if(obj->tail+1==obj->head){
    //     return true;
    // }
    
    //     return false;
    /*这里判断是否满，我们画图可以得到在多开辟一个空间的时候，每当tail+1=head就满了，考虑到可能tail
    +1为-1，故进行了讨论判断*/

    //简化：
    return (obj->tail+1)%(obj->k+1)==obj->head;
    //%(k+1)可以将越界的下标变成-1
}

void myCircularQueueFree(MyCircularQueue* obj) {
   free(obj->a);
   obj->a=NULL;
   free(obj);
   obj=NULL;//先释放掉开辟的数组空间内存，再把结构体的空间释放，指针置空
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

测试：

int main() {
    MyCircularQueue* m = myCircularQueueCreate(3);
    myCircularQueueEnQueue(m, 1);
    myCircularQueueEnQueue(m, 2);
    myCircularQueueEnQueue(m, 3);
    myCircularQueueEnQueue(m, 4);
    printf("%d ", myCircularQueueRear(m));
    myCircularQueueIsFull(m);
    myCircularQueueDeQueue(m);
    myCircularQueueEnQueue(m, 4);
    printf("%d ", myCircularQueueRear(m));
    myCircularQueueFree(m);



    return 0;
}