实现一个栈,要求实现Push(栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1)
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;
}