两种方式实现一个栈，要求实现Push（栈）、Pop（入栈）、Min（返回最小值）的时间复杂度为O

实现一个栈，要求实现Push（栈）、Pop（入栈）、Min（返回最小值）的时间复杂度为O

1：   

如图，入栈时每次入栈两个元素。即入栈的数据与当前的最小值，将两个元素封装为一个结构体，返回时直接返回结构体中的最小值min，便可实现返回最小值的时间复杂度为O（1）；

stack.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

#define MAX_SZIE 10

typedef int ElemType;
typedef struct Elem
{
	ElemType _data;
	ElemType _mindata;

}Elem;

typedef Elem DataType;
typedef struct stack
{
	DataType  _arr[MAX_SZIE];
	int _size;
}stack;

void stackinit(stack *s);
void stackpush(stack *s, DataType data);
void stackpop(stack *s);
DataType stacktop(stack *s);
void stackprint(stack *s);
//////////////////////////////////////
void Minstackinit(stack *s);
void Minstackpop(stack *s);
void Minstackpush(stack *s,ElemType data);
DataType Minstacktop(stack *s);
ElemType Minstackmin(stack *s);

stack.c

#include"stack.h"
void stackinit(stack *s)
{
	assert(s);
	s->_size = 0;
}

void stackpush(stack *s, DataType data)
{
	assert(s);
	if (s->_size == MAX_SZIE)
		return;
	s->_arr[s->_size] = data;
	s->_size += 1;
}

void stackpop(stack *s)
{
	assert(s);
	if (s->_size == 0)
		return;
	s->_size -= 1;
}
DataType stacktop(stack *s)
{
	assert(s);
	if (s->_size == 0)
		exit(0);
	printf("栈顶 %d\n", s->_arr[s->_size - 1]);
	return s->_arr[s->_size - 1];
}
void stackprint(stack *s)
{
	assert(s);
	if (s->_size == 0)
		return;
	for (int i = 0;i < s->_size;i++)
	{
		printf("%d-> ",s->_arr[i]);
	}
	printf("\n");
}
//////////////////////////////////////
void Minstackinit(stack *s)
{
	stackinit(s);
}
void Minstackpop(stack *s)
{
	assert(s);
	if (s->_size == 0)
	{
		return;
	}
	s->_size -= 1;
}
void Minstackpush(stack *s,ElemType data)
{
	DataType e;
	assert(s);
	if (s->_size == 0)
	{
		e._data = e._mindata = data;
		stackpush(s,e);
	}
	else
	{
		e = Minstacktop(s);
		if (e._mindata > data)
		{
			e._mindata = data;
		}
		e._data = data;
		stackpush(s,e);
	}

}

DataType Minstacktop(stack *s)
{
	assert(s);
	if (s->_size == 0)
		exit(0);
	return s->_arr[s->_size - 1];
}
ElemType Minstackmin(stack *s)
{
	assert(s);
	if (s->_size == 0)
		return 0;
	return s->_arr[s->_size - 1]._mindata;
}
//////////////////////////////////////
test()
{
	stack s;
	Minstackinit(&s);
	Minstackpush(&s, 2);
	Minstackpush(&s, 3);
	Minstackpush(&s, 4);
	Minstackpush(&s, 1);
	Minstackpush(&s, 5);
	printf("%d\n", Minstacktop(&s));
	printf("%d\n", Minstackmin(&s));
	
	
	//stackinit(&s);//栈测试
	//stackpush(&s, 1);
	//stackpush(&s, 2);
	//stacktop(&s);
	//stackprint(&s);
}

int main()
{
	test();
	system("pause");
	return 0;
}

2:使用两个栈的方式实现。

   1：如果栈为空，元素同时入两个栈。

  2：第二次入栈时，先将元素入datastack，该元素和minstack中的栈顶元素比较，如果小于等于Mmnstack的栈顶元素，则入minstack，否则不            入。

  3: 出栈时，如果两栈顶元素相同，则均出栈，否则，只需datastack里的元素出栈

stack.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

#define MAX_SZIE 10

typedef int DataType;
typedef struct stack
{
	DataType  _arr[MAX_SZIE];
	int _size;
}stack;
typedef struct minstack
{
	struct stack _data;
	struct stack _mindata;
}minstack;

void stackinit(stack *s);
void stackpush(stack *s, DataType data);
void stackpop(stack *s);
DataType stacktop(stack *s);
void stackprint(stack *s);
//////////////////////////////////////
void Minstackinit(minstack *s);
void Minstackpop(minstack *s);
void Minstackpush(minstack *s, int data);
DataType Minstacktop(minstack *s);
DataType Minstackmin(minstack *s);

stack.c

#include"stack.h"
void stackinit(stack *s)
{
	assert(s);
	s->_size = 0;
}

void stackpush(stack *s, DataType data)
{
	assert(s);
	if (s->_size == MAX_SZIE)
		return;
	s->_arr[s->_size] = data;
	s->_size += 1;
}

void stackpop(stack *s)
{
	assert(s);
	if (s->_size == 0)
		return;
	s->_size -= 1;
}
DataType stacktop(stack *s)
{
	assert(s);
	if (s->_size == 0)
		exit(0);
	return s->_arr[s->_size - 1];
}
void stackprint(stack *s)
{
	assert(s);
	if (s->_size == 0)
		return;
	for (int i = 0;i < s->_size;i++)
	{
		printf("%d-> ",s->_arr[i]);
	}
	printf("\n");
}
//////////////////////////////////////
void Minstackinit(minstack *s)
{
	assert(s);
	stackinit(&(s->_data));
	stackinit(&(s->_mindata));
}

void Minstackpop(minstack *s)
{
	assert(s);
	if (s->_data._size == 0)
		return;
	else
	{
		if (stacktop(&(s->_data)) == stacktop(&(s->_mindata)))
		{
			stackpop(&(s->_data));
			stackpop(&(s->_mindata));
		} 
		stackpop(&(s->_data));
	}
}
void Minstackpush(minstack *s, int data)
{
	assert("s");
	if (s->_mindata._size == 0)
	{
		stackpush(&(s->_data),data);
		stackpush(&(s->_mindata),data);
	}
	else
	{
		if (stacktop(&(s->_mindata)) > data)
		{
			stackpush(&(s->_data), data);
			stackpush(&(s->_mindata), data);
		}
		stackpush(&(s->_data), data);

	}
}
DataType Minstacktop(minstack *s)
{
	assert(s);
	if (s->_data._size == 0)
		return 0;
	return stacktop(&s->_data);
}

DataType Minstackmin(minstack *s)
{
	assert(s);
	if (s->_mindata._size == 0)
		return 0;
	return stacktop(&(s->_mindata));
}

test()
{
	minstack s;
	Minstackinit(&s);
	Minstackpush(&s, 3);
	Minstackpush(&s, 2);
	Minstackpush(&s, 4);
	Minstackpush(&s, 5);
	Minstackpush(&s, 1);
	Minstackpush(&s, 6);
	
	printf("栈顶元素为：%d\n", Minstacktop(&s));
	printf("最小值为：%d\n", Minstackmin(&s));

}

int main()
{
	test();
	system("pause");
	return 0;
}