21-实现带有min函数的栈和队列

一、题目描述

【带有min函数的栈】

实现一个栈，带有入栈（Push），出栈（Pop），取最小元素（getMin）三个方法。要保证三个方法的时间复杂度都尽可能小

【带有min函数的队列】

实现一个队列，带有出队（deQueue），入队（enQueue），取最小元素（getMin）三个方法。要保证三个方法的时间复杂度都尽可能小

二、解题思路

【带有min函数的栈】思路

思路一：额外申请一个栈，用于记录当前的最小值
思路二：只用一个栈，用于存与最小值的差值

【带有min函数的队列】思路

假设原队列为A，辅助队列为B（用于存储当前最小值）
入队操作
1）当第一个元素进入到队列A中时，由于当前这个唯一的元素是队列A中的最小值，故将该元素也放入队列B中
2）每当有新元素要进入辅助队列时，就进行比较新元素与辅助队列rear指向的值的大小，
    a）若辅助队列B rear指向的值大于即将入队B的值elem时，则将rear指向的值出队，直到rear指向的值小于等于elem
    b）若辅助队列B rear指向的值小于等于即将入队B的值elem时，则该elem值入队
出队&&getMin()操作
原队列A出队：正常出队
辅助队列B出队：当辅助队列队首元素值==原队列队首元素值，则出队--该值即为min值

三、解题算法

1、带有min函数的栈 -- 用辅助栈存min值

/******************************************
author:tmw
date:2018-9-2
******************************************/
#include 
#include 
#include 
#include 

#define MAXSIZE 100
typedef struct Stack
{
    int data[MAXSIZE];
    int top;
}Stack;

/*****加辅助空间的最小栈****/
bool _Push( Stack* stk, Stack* temp_stk, int elem )
{
    if(stk->top == MAXSIZE-1)
        return false;
    stk->top++;
    stk->data[stk->top] = elem;

    /**辅助栈操作**/
    if( temp_stk->top==0 || elem < temp_stk->data[temp_stk->top] )
    {
        temp_stk->top++;
        temp_stk->data[temp_stk->top] = elem;
    }
    else
    {
        temp_stk->top++;
        temp_stk->data[temp_stk->top] = temp_stk->data[temp_stk->top-1];
    }
    return true;
}
bool _Pop( Stack* stk, Stack* temp_stk )
{
    if(stk->top == 0)
        return false;
    stk->top--;

    if(temp_stk->top == 0)
        return false;
    temp_stk->top--;

    return true;
}
int getMin( Stack* temp_stk )
{
    return temp_stk->data[temp_stk->top];
}

2、带有min函数的栈 -- 构建差值栈

/**差值最小栈**/
int min_value = INT_MAX;
void Push_diy( Stack* stk, int elem )
{
    if( stk->top==0 )
    {
        min_value = elem;
        stk->data[stk->top++] = 0; //存差值
        return;
    }
    if( elem < min_value )
    {
        stk->data[stk->top++] = elem - min_value;
        min_value = elem;
    }
    else
        stk->data[stk->top++] = elem - min_value;

}
int getMin()
{
    return min_value;
}
void Pop_diy( Stack* stk )
{
    /**如果当前栈顶元素为负数，说明min有更新**/
    if( stk->data[stk->top]<0 )
        min_value = min_value - stk->data[stk->top];

    stk->top--;
    getMin();
}

3、带有min函数的队列

/************************************************
author:tmw
date:2018-9-2
************************************************/
#include 
#include 

#define MAXSIZE 100
typedef struct Queue
{
    int data[MAXSIZE];
    int front;
    int rear;
}Queue;

/**实现一个带min函数的队列**/
//入队操作
void Enqueue(Queue *A, Queue* temp_B, int elem)
{
    //当辅助队列为空，则直接入队
    if( temp_B->front%MAXSIZE == temp_B->rear )
        temp_B->data[temp_B->rear] = elem;
    //辅助队列非空
    else
    {
        //辅助队列队尾元素大于elem,则出队
        while( temp_B->front%MAXSIZE != temp_B->rear && temp_B->data[temp_B->rear]>elem )
            temp_B->rear--;
        temp_B->data[temp_B->rear] = elem;
    }
    A->data[A->rear] = elem;
}
int getMin( Queue* temp_B )
{
    return temp_B->data[temp_B->front];
}

void Dequeue(Queue* A, Queue* temp_B)
{
    if( A->front%MAXSIZE!=A->rear && temp_B->front%MAXSIZE!=temp_B->rear )
    {
        //当辅助队列队首元素值==原队列队首元素值，则出队
        if( temp_B->data[temp_B->front] == A->data[A->front] )
        {
            getMin(temp_B);
            temp_B->front++;
        }
        A->front++;
    }
}

梦想还是要有的，万一实现了呢~~~~ヾ(◍°∇°◍)ﾉﾞ~~~~