微软100题-第2题设计包含min函数的栈

scala版本

package ms

import scala.collection.mutable.ArrayBuffer
/**
* 2.设计包含min函数的栈（栈）
定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。
要求函数min、push以及pop的时间复杂度都是O(1)。
*/
class CustomStack[T<%Ordered[T]]{
var data:ArrayBuffer[T]=ArrayBuffer[T]();
var mins:ArrayBuffer[T]=ArrayBuffer[T]();
def push(value:T)={
data.append(value)
if(mins.isEmpty){
mins.append(value)
}else{
if(mins(mins.length-1)>value){
mins.append(value)
}
}
}
def pop():Option[T]={
if(data.length==0){
return None
}
val v=data.remove(data.length-1);
if(v==mins(mins.length-1)){
mins.remove(mins.length-1)
}
return Some(v)
}

def min():Option[T]={
if(mins.length==0){
return None
}
Some(mins(mins.length-1))
}
}

object MicroSoft002 extends App{
val stack=new CustomStack[Int]();
stack.push(5);
stack.push(10);
stack.push(3);
println(stack.min)
stack.pop()
println(stack.min)
stack.pop()
println(stack.min)
stack.pop()
println(stack.min)
}

python版本

'''
Created on 2017-1-9
2.设计包含min函数的栈（栈）
定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。
要求函数min、push以及pop的时间复杂度都是O(1)。
@author: admin
'''
class MinStack:
def __init__(self):
self.mainAry=[]
self.auxAry=[]
def push(self,data):
if len(self.mainAry)==0:
self.auxAry.append(data)
elif data<=self.auxAry[len(self.auxAry)-1]:
self.auxAry.append(data)
self.mainAry.append(data)
def pop(self):
if len(self.mainAry)==0:
raise IndexError
data=self.mainAry[len(self.mainAry)-1]
del self.mainAry[len(self.mainAry)-1]
if data==self.auxAry[len(self.auxAry)-1]:
del self.auxAry[len(self.auxAry)-1]
return data
def min(self):
if len(self.auxAry)==0:
raise IndexError
else:
return self.auxAry[len(self.auxAry)-1]
if __name__ == '__main__':
stack=MinStack()
stack.push(7)
stack.push(5)
stack.push(9)
stack.push(2)
stack.push(4)
print(stack.pop())
print(stack.min())
print(stack.pop())
print(stack.min())
print(stack.pop())
print(stack.min())
print(stack.pop())
print(stack.min())

java版本

地址1 http://blog.csdn.net/hxpjava1/article/details/22096809

c语言版本

/*
* microsoft002.c
*
*  Created on: 2017年1月26日
*      Author: admin
*
2.设计包含min函数的栈（栈）
定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。
要求函数min、push以及pop的时间复杂度都是O(1)。

*/
#include <stdio.h>

#define ARRAY_MAX_LENGHT 100

void push(int data);
int min();
int pop();

//主数组
static int mainArray[ARRAY_MAX_LENGHT];
//辅助数组
static int auxArray[ARRAY_MAX_LENGHT];

static int mainIndex=0;
static int auxIndex=0;

int main2(){
push(5);
push(4);
push(10);
printf("%d\n",min());
printf("%d\n",pop());
printf("%d\n",min());
printf("%d\n",pop());
printf("%d\n",min());
return 0;
}

void push(int data){
mainArray[mainIndex++]=data;
if(auxIndex==0){
auxArray[auxIndex++]=data;
}else{
if(auxArray[auxIndex-1]>data){
auxArray[auxIndex++]=data;
}
}
}
int min(){
if(auxIndex==0){
return -1;
}
return auxArray[auxIndex-1];
}
int pop(){
if(mainIndex==0){
return -1;
}
if(mainArray[mainIndex-1]==auxArray[auxIndex-1]){
auxIndex--;
}
return mainArray[--mainIndex];
}

c++版本

/*
* microsoft002.cpp
*
* Created on: 2017年2月6日
* Author: admin
2.设计包含min函数的栈（栈）
定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。
要求函数min、push以及pop的时间复杂度都是O(1)。
*/
#define MAX_LEN 100
#include "iostream"
using namespace std;

template <typename T>
class MinStack{
public:
MinStack(){
mainIndex=0;
auxIndex=0;
}
public:
void push(T value){
mainArray[mainIndex++]=value;
if(auxIndex==0){
auxArray[auxIndex++]=value;
}else{
if(value<=auxArray[auxIndex-1]){
auxArray[auxIndex++]=value;
}
}
}

T pop(){
T tmp=mainArray[mainIndex-1];
if(auxArray[auxIndex-1]==mainArray[mainIndex-1]){
mainIndex--;
auxIndex--;
}else{
mainIndex--;
}
return tmp;
}

T min(){
return auxArray[auxIndex-1];
}
private:
int mainIndex;
int auxIndex;
T mainArray[MAX_LEN];
T auxArray[MAX_LEN];
};

int main002(){
MinStack<int> stack;
stack.push(10);
stack.push(9);
stack.push(12);
stack.push(6);
cout<<stack.min()<<endl;
cout<<stack.pop()<<endl;
cout<<stack.min()<<endl;
stack.push(3);
cout<<stack.min()<<endl;
cout<<stack.pop()<<endl;
cout<<stack.min()<<endl;
return 0;
}