leetcode(栈实现队列，循环队列)

1.栈实现队列：

先定义一个只入的栈，在定义一个只出的栈

由于用的是C，先实现一个栈：

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;

void StackInit(Stack* ps)// 初始化
{
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void StackPush(Stack* ps, STDataType data)// 入栈
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newcapacit = ps->capacity == 0 ? 4 : ps->capacity * 2;
		int* tmp = (int*)realloc(ps->a, sizeof(int) * newcapacit);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacit;
	}
	ps->a[ps->top] = data;
	ps->top++;
}

void StackPop(Stack* ps)// 出栈
{
	assert(ps);

	ps->top--;
}

STDataType StackTop(Stack* ps)// 获取栈顶元素
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
	// int i = 0;
	// for (i = 0;i < ps->top;i++)
	// {
	// 	;
	// }
	// return --i;
}

int StackSize(Stack* ps)// 获取栈中有效元素个数
{
	return ps->top;
}

int StackEmpty(Stack* ps)// 检查是否有元素
{
	if (ps->top == 0)
	{
		return 0;
	}
	else
		return 1;
}

void StackDestroy(Stack* ps)// 销毁栈
{
	ps->top = 0;
}

调用栈：

typedef struct {
    Stack left;
		Stack right;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
		StackInit(&obj->left);// 初始化
		StackInit(&obj->right);// 初始化
		return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->left,x);//入left栈
}

int myQueuePop(MyQueue* obj) {
    int ans = myQueuePeek(obj);//获取 right的栈顶元素
		StackPop(&obj->right);// 删除栈顶元素
		return ans;
}

int myQueuePeek(MyQueue* obj) {
    if(StackEmpty(&obj->right)==0)//判断right是否为空
		{
			  while(StackEmpty(&obj->left))
				{
					StackPush(&obj->right,StackTop(&obj->left));// left数据导到right里面
					StackPop(&obj->left);// 删除left栈顶元素
				}
		}
		return StackTop(&obj->right);// 返回right 栈顶元素
}

bool myQueueEmpty(MyQueue* obj) {
    return !StackEmpty(&obj->left) && !StackEmpty(&obj->right);//判断是否为空
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->left);//销毁
		StackDestroy(&obj->right);
		free(obj);
}

循环队列：这里用数组实现

f

ront 代表队首元素

back 代表队尾元素的下一个

判断为满 即 (back+1) % (k+1) == front;

判断为空 即 back == front

插入前先判断数组是否满，在插入

为了防止插入无效(数组遵循循环)  插入成功后 （back+1）%(k+1)

删除队首元素先判断是否为空，在删除

和插入一样，也要进行 %(k+1) 操作

先判断是否为空，然后直接获取 a [front]

先判断是否为空

返回 a[back-1]

当back为0时就要而外判断 即：当 k == 0 时，返回a[k]

还有一种方法就是返回 ((back-1) + (k+1)) % (k+1)   ==   ((back) + (k)) % (k+1)

源码：

typedef struct {
    int *a;
    int k;
    int front;
    int back;
} MyCircularQueue;// 创建结构体数组


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));
    obj->k=k;
    obj->front=0;
    obj->back=0;
    return obj;
} // 开辟 k+1 个空间

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    // return obj->front==obj->back;
    if(obj->front==obj->back)
    return true;
    else
    return false;
} // 判断是否为空

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    if((obj->back+1)%(obj->k+1)==obj->front)
    return true;
    else
    return false;
} // 判断是否为满

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    return false;

    obj->a[obj->back]=value;
    obj->back = (obj->back+1)%(obj->k+1);
    return true;
} // 队尾插入

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
     if(myCircularQueueIsEmpty(obj))
     return false;

     obj->front=(obj->front+1)%(obj->k+1);
     return true;
} // 队首删除

int myCircularQueueFront(MyCircularQueue* obj) {
     if(myCircularQueueIsEmpty(obj))
     return -1;

     return obj->a[obj->front];
} // 返回队首元素

int myCircularQueueRear(MyCircularQueue* obj) {
     if(myCircularQueueIsEmpty(obj))
     return -1;

    //  if(obj->back==0)
    //  return obj->a[obj->k];

    //  return obj->a[obj->back-1];
    
    return obj->a[(obj->back + obj->k) % (obj->k+1) ];
} // 返回队尾元素

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
} // 销毁