C语言循环队列与用队列实现栈问题解析

typedef struct 
{
    int* a;
    int head;
    int tail;
    int k;
} MyCircularQueue;
bool myCircularQueueIsEmpty(MyCircularQueue* obj) ;
bool myCircularQueueIsFull(MyCircularQueue* obj) ;

MyCircularQueue* myCircularQueueCreate(int k)
{
    //给结构体指针变量开辟空间，否则为野指针。
    MyCircularQueue* new =(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    int* b = (int*)malloc(sizeof(int)*(k+1));
    new->a = b;
    new->head = 0;
    new->tail = 0;
    new->k = k;
    return new;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    assert(obj);
    if(myCircularQueueIsFull(obj))
    {
        return false;
    }
    
    obj->a[obj->tail] = value;
    if(obj->tail == obj->k)
    {
        obj->tail = 0;
    }
    else
    {
     obj->tail++;
    }
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj)
 {
     assert(obj);
     if(myCircularQueueIsEmpty(obj))
     {
         return false;
     }
      if(obj->head == obj->k)
     {
        obj->head = 0;
    }
        else
        {
            obj->head++;
        }
    
     return true;

}

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

}

int myCircularQueueRear(MyCircularQueue* obj)
 {
     assert(obj);
     if(myCircularQueueIsEmpty(obj))
     {
         return -1;
     }
     if(obj->tail == 0)
     {
         return obj->a[obj->k];
     }
     return obj->a[obj->tail-1];

}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    assert(obj);
    return obj->head == obj->tail;

}

bool myCircularQueueIsFull(MyCircularQueue* obj)
 {
     assert(obj);
     if(obj->head==0 && obj->tail == obj->k)
     {
         return true;
     }
     else
     {
         return obj->head == obj->tail+1;
     }

}

void myCircularQueueFree(MyCircularQueue* obj) 
{
    assert(obj);
    free(obj->a);
    free(obj);

}

 //假设后调整
     Queue* emptyQ = &obj->q1;
    Queue* nonEmptyQ = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ = &obj->q2;
        nonEmptyQ = &obj->q1;
    }

typedef int QDataType;

typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	//size_t size;
}Queue;

void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
bool QueueEmpty(Queue* pq);
size_t QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	assert(newnode);

	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		assert(pq->head == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head && pq->tail);

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);


	return pq->head == NULL;
}

size_t QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	size_t size = 0;
	while (cur)
	{
		size++;
		cur = cur->next;
	}

	return size;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->tail);

	return pq->tail->data;
}


//创建两个队列
typedef struct
 {
    Queue q1;
    Queue q2;
} MyStack;

//初始化两个队列
MyStack* myStackCreate()
 {
     MyStack* new = (MyStack*)malloc(sizeof(MyStack));
     assert(new);
     QueueInit(&new->q1);
     QueueInit(&new->q2);

     return new;

}
//谁不为空就在谁里面入队
void myStackPush(MyStack* obj, int x)
{
    assert(obj);
    if(!QueueEmpty(&obj->q2))
    {
        QueuePush(&obj->q2, x);
    }
    else
    {
        QueuePush(&obj->q1, x);
    }
}

int myStackPop(MyStack* obj) 
{
    assert(obj);
    //假设后调整
     Queue* emptyQ = &obj->q1;
    Queue* nonEmptyQ = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ = &obj->q2;
        nonEmptyQ = &obj->q1;
    }
   
   while(QueueSize(nonEmptyQ) > 1)
    {
        int front = QueueFront(nonEmptyQ);
        QueuePush(emptyQ, front);
        QueuePop(nonEmptyQ);
    }

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

    return top;
}

int myStackTop(MyStack* obj) 
{
  assert(obj);  
  int ret = 0;
  if(!QueueEmpty(&obj->q1))
  {
      ret = QueueBack(&obj->q1);
  }
  else
  {
      ret = QueueBack(&obj->q2);
  }
  return ret;
}

bool myStackEmpty(MyStack* obj)
 {
     assert(obj);
     return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) 
{
    assert(obj);
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
    free(obj);

}