栈与对列 练习题

1.实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间 复杂度为O(1)

创建2个栈 s 和 min ，入栈时，先入栈s，在判断是否<=栈min的top元素，如果是，则同时也入min栈，否则不入。

出栈时，如果s栈的top元素与min栈的top元素相等，则两个都出栈，否则只出s栈的top取min值时直接返回min栈top元素即可

function.h

#pragma once
#include"stack.h"

void minstack_push(Stack *s, Stack *min, DataType x)
{
    assert(s);
    assert(min);
    StackPush(s, x);
    if (min->_top == 0 || StackTop(min) >= x)
    {
        StackPush(min,x);
    }

}
void minstack_pop(Stack *s, Stack *min)
{
    assert(s);
    assert(min);
    if (StackTop(s) == StackTop(min))
    {
        StackPop(min);
    }
    StackPop(s);
}

int minstack_min(Stack *min)
{
    assert(min);

    return StackTop(min);

}

2.使用两个栈实现一个队列

思路：创建两个栈s1和s2，

当要入数据时，只往s1当中入数据，

需要出数据时，先看s2里是否有元素，如果有，则先出s2内的数据，如果s2为空，则先将s1的数据依次导到s2中，再出数据。

function.h

#pragma once
#include"stack.h"

void double_stack_to_queue_push(Stack *s1,DataType x)
{
    assert(s1);
    StackPush(s1,x);
}
void double_stack_to_queue_pop(Stack *s1, Stack *s2)
{
    assert(s1);
    assert(s2);
    if (StackEmpty(s2) == 0)
    {
        printf("%d\t", StackTop(s2));
        StackPop(s2);
        return;
    }
    else
    {
        if (StackEmpty(s1) == 1)
        {
            printf("两个栈均无数据，无法出栈！");
            return;
        }
        while (StackEmpty(s1) == 0)
        {
            StackPush(s2, StackTop(s1));
            StackPop(s1);
        }
        printf("%d\t", StackTop(s2));
        StackPop(s2);
    }
}

3使用两个队列实现一个栈

思路：创建2个队列 q1和q2，

入数据时，如果两个队列都为空，则往q1入数据，如果q1和q2中有一个为空，一个不为空，则往不为空的那个队列入数据（即一直保持一个队列为空）

当要出数据时，将不为空的队列中的n-1个数据挪至为空的队列，这时候原本不为空的队列中只剩一个数据且是最后入的数据，pop掉即可。（仍然保持一个队列为空）

functions.h

#pragma once
#include"queue.h"

void double_queue_to_stack_push(Queue *q1, Queue *q2, DataType x)
{
    if (QueueEmpty(q1) == 0 && QueueEmpty(q2) == 0)//两个队列都空
    {
        QueuePush(q1, x);
    }
    else if (QueueEmpty(q1) == 0)//往不为空的那个队列入数据
    {
        QueuePush(q2, x);
    }
    else
    {
        QueuePush(q1, x);
    }
}

void double_queue_to_stack_pop(Queue *q1, Queue *q2)
{
    assert(q1);
    assert(q2);
    if (QueueEmpty(q1) == 0 && QueueEmpty(q2) == 0)
    {
        printf("两个队列均无数据！");
        return;
    }
    else if (QueueEmpty(q1) == 0)
    {
        size_t size2 = QueueSize(q2);

        while (size2 != 1)
        {
            QueuePush(q1, QueueFront(q2));
            QueuePop(q2);
            size2--;
        }
        printf("%d", QueueFront(q2));
        QueuePop(q2);
        q2->_tail = q2->_head;
    }
    else
    {
        size_t size1 = QueueSize(q1);
        while (size1 != 1)
        {
            QueuePush(q2, QueueFront(q1));
            QueuePop(q1);
            size1--;
        }
        printf("%d", QueueFront(q1));
        QueuePop(q1);
        q1->_tail = q1->_head;
    }

}

4.元素出栈、入栈顺序的合法性。如入栈的序列(1,2,3,4,5)，出栈序列为 (4,5,3,2,1)

思路:给定入栈序列与出栈序列，用2个指针分别指向他们。

如果指针所指内容相等，说明入栈后立刻出栈，两个指针都后移.

当指针所指内容不相等时，说明入栈序列的值可能暂时存在栈中，稍后会出栈，故对入栈指针进行后移操作，出栈指针不变。

等到入栈序列指针指向NULL后，说明此时要么出栈指针也为空，要么剩余出栈序列与栈内元素一 一匹配才合法。否则不合法。

#include <stdio.h>  
#include <stdlib.h>  
#define MaxSize 60   
#define OK      1        
#define ERROR   0        
#define TRUE    1        
#define FALSE   0      
typedef int ElemType;    
typedef int Status;    
typedef struct {    
    ElemType    data[MaxSize];    
    int         top1;                      
    int         top2;                     
}Stack,  *pStack;    

Status init_Stack(pStack S)  
{  
    S->top1 = -1;  
    S->top2 = MaxSize;  
    return OK;   
}  

Status push_Stack(pStack S, ElemType e, int stackNumber)  
{  
    if (S->top1+1 == S->top2)  
        return ERROR;  
    switch(stackNumber)  
    {  
        case 1:       
                S->data[++S->top1] = e;         
                break;  
        case 2:       
                S->data[--S->top2] = e;         
                break;  
    }  
    return OK;  
}  


Status pop_Stack(pStack S, ElemType *e, int stackNumber)  
{  
    if (1 == stackNumber)  
    {     
        if (-1 == S->top1)         
            return ERROR;  
        *e = S->data[S->top1--];  
    }  
    else if (2 == stackNumber)  
    {  
        if (MaxSize == S->top2)  
            return ERROR;  
        *e = S->data[S->top2++];  
    }  
    return OK;  
}  


Status dis_pStack(pStack S, int stackNumber)  
{  
    int i;  
    if (1 == stackNumber)  
    {  
        if (-1 == S->top1)  
            return ERROR;  

        printf("栈1中的元素为：\n");  
        for (i=0; i<=S->top1; ++i)  
            printf("%d ", S->data[i]);  
        printf("\n==================================\n");  
    }  
    else if (2 == stackNumber)  
    {  
        if (MaxSize == S->top2)  
            return ERROR;  
        printf("栈2中的元素为：\n");  
        for (i=MaxSize-1; i>=S->top2; --i)      
            printf("%d ", S->data[i]);  
        printf("\n==================================\n");  
    }  
}  

int main()  
{  
    printf("======共享栈===========\n\n");  
    Stack S;  
    ElemType e;  
    init_Stack(&S);  
    push_Stack(&S, 1, 1);  
    push_Stack(&S, 2, 1);  
    push_Stack(&S, 3, 1);  
    push_Stack(&S, 4, 1);  
    push_Stack(&S, 5, 1);  
    push_Stack(&S, 6, 1);  
    pop_Stack(&S, &e, 1);  
    push_Stack(&S, 10, 2);  
    push_Stack(&S, 9, 2);  
    push_Stack(&S, 8, 2);  
    push_Stack(&S, 7, 2);  
    dis_pStack(&S, 1);  
    dis_pStack(&S, 2);  
    return 0;  
}