代码随想录算法训练营第十天| 232.用栈实现队列、225. 用队列实现栈

232.用栈实现队列 https://leetcode.cn/problems/implement-queue-using-stacks/

typedef struct {
    int element_num;
    int ele_array[128];
}mystack;

void mystack_push(mystack    *obj, int x)
{
    if (obj->element_num >= sizeof(obj->ele_array)/sizeof(obj->ele_array[0]))
        return;

    obj->ele_array[obj->element_num++] = x;
    return;
}

int mystack_pop(mystack *obj)
{
    int ret = 0;
    if (obj->element_num <= 0)
        return 0;
    ret = obj->ele_array[--obj->element_num];
    return ret;
}

int mystack_peek(mystack *obj)
{
    return obj->ele_array[obj->element_num - 1];
}

int mystack_size(mystack *obj)
{
    return obj->element_num;
}

int mystack_isempty(mystack *obj)
{
    if (obj->element_num <= 0)
        return 1;
    return 0;
}

typedef struct {
    mystack stack1;
    mystack stack2;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue *tmp_queue = NULL;
    tmp_queue = (MyQueue *)malloc(sizeof(MyQueue));
    if (NULL == tmp_queue) return NULL;
    memset(tmp_queue, 0, sizeof(MyQueue));

    return tmp_queue;
}

void myQueuePush(MyQueue* obj, int x) {
    mystack_push(&obj->stack1, x);
    return;
}

int myQueuePop(MyQueue* obj) {
    int ret = 0;
    int x = 0;
    ret = mystack_isempty(&obj->stack2);
    if (0 == ret)
    {
        ret = mystack_pop(&obj->stack2);
        return ret;
    }
    else if (1 == ret)
    {
        while (1 != mystack_isempty(&obj->stack1))
        {
            x = mystack_pop(&obj->stack1);
            mystack_push(&obj->stack2, x);
        }
    }

    ret = mystack_pop(&obj->stack2);
    return ret;
}

int myQueuePeek(MyQueue* obj) {
    int ret = 0;
    int x = 0;
    ret = mystack_isempty(&obj->stack2);
    if (0 == ret)
    {
        ret = mystack_peek(&obj->stack2);
        return ret;
    }
    else if (1 == ret)
    {
        while (1 != mystack_isempty(&obj->stack1))
        {
            x = mystack_pop(&obj->stack1);
            mystack_push(&obj->stack2, x);
        }
    }

    ret = mystack_peek(&obj->stack2);
    return ret;

}

bool myQueueEmpty(MyQueue* obj) {
    int ret1 = 0;
    int ret2 = 0;

    ret1 = mystack_isempty(&obj->stack1);
    ret2 = mystack_isempty(&obj->stack2);

    if (1 == ret1 && 1 == ret2)
        return 1;
    return 0;
}

void myQueueFree(MyQueue* obj) {
    if (NULL != obj){free(obj); obj = NULL;}
    return;
}

225. 用队列实现栈 https://leetcode.cn/problems/implement-stack-using-queues/

typedef struct _myqueue{
    int ele_num;
    int head_index; //下一个获取数据下标
    int tail_index; //下一个存放数据下标
    int ele_array[128];
}myqueue;

void myqueue_push(myqueue *obj, int x)
{
    if (obj->ele_num >= sizeof(obj->ele_array)/sizeof(obj->ele_array[0]))
        return;

    obj->ele_array[obj->tail_index] = x;
    obj->tail_index = (obj->tail_index + 128 - 1) & 127;
    obj->ele_num++;
    return;
}

int myqueue_pop(myqueue *obj)
{
    int ret = 0;
    if (obj->ele_num < 0)
        return 0;

    ret = obj->ele_array[obj->head_index];
    obj->head_index = (obj->head_index + 128 - 1) & 127;
    obj->ele_num--;
    return ret;
}

int myqueue_peek(myqueue *obj)
{
    int ret = 0;
    if (obj->ele_num < 0)
        return 0;

    ret = obj->ele_array[obj->head_index];
    obj->head_index = (obj->head_index + 128 - 1) & 127;
    return ret;
}

int myqueue_size(myqueue *obj)
{
    return obj->ele_num;
}

int myqueue_isempty(myqueue *obj)
{
    if (0 == obj->ele_num)
        return 1;
    return 0;
}

typedef struct {
    int data_flag; //数据在哪个队列 1-queue 2-queue
    myqueue queue1;
    myqueue queue2;
} MyStack;

MyStack* myStackCreate() {
    MyStack *tmp_stack = NULL;
    tmp_stack = (MyStack *)malloc(sizeof(MyStack));
    if (NULL == tmp_stack) return NULL;
    memset(tmp_stack, 0, sizeof(MyStack));

    tmp_stack->data_flag = 1;
    return tmp_stack;
}

void myStackPush(MyStack* obj, int x) {
    if (1 == obj->data_flag)
        myqueue_push(&obj->queue1, x);
    else if (2 == obj->data_flag)
        myqueue_push(&obj->queue2, x);

    return;
}

int myStackPop(MyStack* obj) {
    int ret = 0;
    if (1 == obj->data_flag)
    {
        while(1 != myqueue_isempty(&obj->queue1))
        {
            ret = myqueue_pop(&obj->queue1);
            if (1 == myqueue_isempty(&obj->queue1))
            {
                obj->data_flag = 2;
                return ret;
            }
            myqueue_push(&obj->queue2, ret);
        }
    }
    else if (2 == obj->data_flag)
    {
        while (1 != myqueue_isempty(&obj->queue2))
        {
            ret = myqueue_pop(&obj->queue2);
            if (1 == myqueue_isempty(&obj->queue2))
            {
                obj->data_flag = 1;
                return ret;
            }
            myqueue_push(&obj->queue1, ret);
        }
    }

    return ret;
}

int myStackTop(MyStack* obj) {
    int ret = 0;
    if (1 == obj->data_flag)
    {
        while(1 != myqueue_isempty(&obj->queue1))
        {
            ret = myqueue_pop(&obj->queue1);
            myqueue_push(&obj->queue2, ret);

        }
        obj->data_flag = 2;
        return ret;
    }
    else if (2 == obj->data_flag)
    {
        while (1 != myqueue_isempty(&obj->queue2))
        {
            ret = myqueue_pop(&obj->queue2);
            myqueue_push(&obj->queue1, ret);
        }
        obj->data_flag = 1;
        return ret;
    }

    return ret;
}

bool myStackEmpty(MyStack* obj) {
    if ((1 == obj->data_flag && 1 == myqueue_isempty(&obj->queue1))
        || (2 == obj->data_flag && 1 == myqueue_isempty(&obj->queue2)))
        return 1;

    return 0;
}

void myStackFree(MyStack* obj) {
    if (NULL != obj){free(obj); obj=NULL;}
    return;
}

思路：用栈实现队列，入队操作，将数据压入栈1，出栈操作，将栈1的数据依次pop，并压入栈2，在从栈2pop

用队列实现栈，栈2作为备用数据存储，栈push，队列push；栈pop，队列的数据依次pop，并push进队列2。