【编程题目】设计包含 min 函数的栈

2.设计包含 min 函数的栈（栈）
定义栈的数据结构，要求添加一个 min 函数，能够得到栈的最小元素。
要求函数 min、push 以及 pop 的时间复杂度都是 O(1)。

我的思路：

用一个额外的元素记录最小值，push时若遇到更小的则更新。但是pop的时候遇到了问题，最小的弹出去了怎么得到下一个最小的值？ 总觉得要排序，再存一个min的链。结果没达到O(1).

/*
2.设计包含 min 函数的栈（栈）
定义栈的数据结构，要求添加一个 min 函数，能够得到栈的最小元素。
要求函数 min、push 以及 pop 的时间复杂度都是 O(1)。
*/
#include <stdio.h>
#include <stdlib.h>

typedef int Elemtype;

typedef struct Stack_Elem
{
Elemtype data;
Stack_Elem * p_next;
};
typedef struct My_Stack
{
Elemtype min;
Stack_Elem * top;
}My_Stack;

Elemtype Stack_Min(My_Stack S)
{
return S.min;
}

void Stack_Push(My_Stack* S, Elemtype e)
{
Stack_Elem * new_element = (Stack_Elem *)malloc(sizeof(Stack_Elem));
new_element->data = e;
new_element->p_next = S->top;
S->top = new_element;

S->min = (S->min < e) ? S->min : e;
}

Elemtype Stack_Pop(My_Stack* S)
{
if(S == NULL)
{
printf("error");
return -1;
}
Stack_Elem * pop_elem = S->top;
S->top = pop_elem->p_next;
pop_elem->p_next = NULL;
Elemtype e = pop_elem->data;
if(e == S->min)
{
Elemtype min = S->top->data;
Stack_Elem * p = S->top;
while(p->p_next != NULL)
{
if (p->data < min)
{
min = p->data;
}
p = p->p_next;
}
S->min = min;
}

free(pop_elem);
return e;
}

int main()
{
My_Stack S;
S.min = 999999;
S.top = NULL;

Stack_Push(&S, 5);
Stack_Push(&S, 4);
Stack_Push(&S, 3);
Stack_Push(&S, 2);
Stack_Push(&S, 1);

Elemtype e = Stack_Min(S);

e = Stack_Pop(&S);
e = Stack_Pop(&S);

e = Stack_Min(S);

return 0;
}

网上找答案，突然恍然大悟，存一个最小值的栈就好了，每次遇到新的最小值就进栈，不是新最小值就不理会。这样是没问题的，如

栈中元素：3 4 2 5 6 1

min栈中的元素：3 2 1

弹出1后

栈中元素：3 4 2 5 6

min栈中的元素：3 2

弹5 6时不会影响 最小值。

网上代码：/article/4690712.html

// minStatck.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <cassert>

using namespace std;

template<typename T>
class StackSuppliedMin{
public:
vector<T> datas;
vector<size_t> minStack;

void push(T data){
datas.push_back(data);
if (minStack.empty() || data < datas[minStack.back()])
minStack.push_back(datas.size()-1);
}

void pop(){
assert(!datas.empty());
if (datas.back() == datas[minStack.back()])
minStack.pop_back();
datas.pop_back();
}

T min(){
assert(!datas.empty() && !minStack.empty());
return datas[minStack.back()];
}

void display(){
cout << "datas = ";
for (unsigned i = 0; i < datas.size(); i ++)
cout << datas[i] << " ";
cout << endl;
cout << "minStack = ";
for (unsigned i = 0; i < minStack.size(); i ++)
cout << datas[minStack[i]] << " ";
cout << endl;
cout << "min = " << datas[minStack.back()] << endl << endl;
}
};
void main()
{
StackSuppliedMin<int> s;
s.push(3);
s.display();
s.push(4);
s.display();
s.push(2);
s.display();
s.push(0);
s.display();
s.pop();
s.display();
s.pop();
s.display();
s.push(0);
s.display();

}