栈和队列及其应用（二）

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

MinStack.h

#include"Stack.h"

typedef int _MSTDataType;

typedef struct MinStack
{
	Stack _st;
	Stack _minst;
}MinStack;

void InitMinStack(MinStack * pms);
void DestoryMinStack(MinStack * pms);

void PushMinStack(MinStack * pms, _MSTDataType x);
void PopMinStack(MinStack * pms);

_MSTDataType TopMinStack(MinStack * pms);

MinStack.c

#include"MinStack.h"

void InitMinStack(MinStack * pms)
{
	assert(pms);
	InitStack(&pms->_st);
	InitStack(&pms->_minst);
}

void DestoryMinStack(MinStack * pms)
{
	assert(pms);
	DestoryStack(&pms->_st);
	DestoryStack(&pms->_minst);
}

void PushMinStack(MinStack * pms, _MSTDataType x)
{
	assert(pms);
	PushStack(&pms->_st, x);
	if (isEmptyStack(&pms->_minst) == 0 || x <= TopStack(&pms->_minst))
	{
		PushStack(&pms->_minst, x);
	}
}

void PopMinStack(MinStack * pms)
{
	assert(pms);
	if (TopStack(&pms->_st) == TopStack(&pms->_minst))
	{
		PopStack(&pms->_minst);
	}
	PopStack(&pms->_st);
}

_MSTDataType TopMinStack(MinStack * pms)
{
	assert(pms);
	return TopStack(&pms->_minst);
}

元素出栈、入栈顺序的合法性。如入栈的序列(1,2,3,4,5)，出栈序列为(4,5,3,2,1)

int IsLegalStackOrder(int * in, int in_size, int * out, int out_size)
{
	Stack st;
	int in_index = 0, out_index = 0;
	assert(in && out && (in_size == out_size));
	InitStack(&st);
	while (in_index < in_size)
	{
		PushStack(&st, *(in + in_index));
		++in_index;
		while ((TopStack(&st) == *(out + out_index)) && isEmptyStack(&st))
		{
			PopStack(&st);
			++out_index;
		}
	}
	if (isEmptyStack(&st) == 0)
	{
		DestoryStack(&st);
		return 1;
	}
	else
	{
		DestoryStack(&st);
		return 0;
	}
}

 

用一个数组实现两个栈（共享栈）

ShareStack.h

#include"Stack.h"

typedef int _SSDataType;

typedef struct ShareStack
{
	_SSDataType * _ssa;
	int _sscapacity;
	int _sstop1;
	int _sstop2;
}ShareStack;

void InitShareStack(ShareStack * pss);
void DestoryShareStack(ShareStack * pss);

void PushShareStack(ShareStack * pss, _SSDataType x, int which);
void PopShareStack(ShareStack * pss, int which);

_SSDataType TopShareStack(ShareStack * pss, int which);

int isEmptyShareStack(ShareStack * pss, int which);
int SizeShareStack(ShareStack * pss, int which);

ShareStack.c

#include"ShareStack.h"

void InitShareStack(ShareStack * pss)
{
	assert(pss);
	pss->_ssa = (_SSDataType *)malloc(sizeof(_SSDataType) * 4);
	assert(pss->_ssa);
	pss->_sstop1 = 0;
	pss->_sstop2 = 1;
	pss->_sscapacity = 4;
}

void DestoryShareStack(ShareStack * pss)
{
	assert(pss);
	if (pss->_ssa)
	{
		free(pss->_ssa);
		pss->_ssa = NULL;
		pss->_sstop1 = 0;
		pss->_sstop2 = 1;
	}
}

void PushShareStack(ShareStack * pss, _SSDataType x, int which)
{
	assert(pss && (which == 1 || which == 2));
	switch (which)
	{
	case 1: 
		if (pss->_sstop1 >= pss->_sscapacity)
		{
			pss->_ssa = (_SSDataType *)realloc(pss->_ssa, sizeof(_SSDataType)*pss->_sscapacity * 2);
			pss->_sscapacity *= 2;
		}
		pss->_ssa[pss->_sstop1] = x;
		pss->_sstop1 += 2;
		break;
	case 2:
		if (pss->_sstop2 >= pss->_sscapacity)
		{
			pss->_ssa = (_SSDataType *)realloc(pss->_ssa, sizeof(_SSDataType)*pss->_sscapacity * 2);
			pss->_sscapacity *= 2;
		}
		pss->_ssa[pss->_sstop2] = x;
		pss->_sstop2 += 2;
		break;
	default:
		break;
	}
}

void PopShareStack(ShareStack * pss, int which)
{
	assert(pss && (which == 1 || which == 2));
	switch (which)
	{
	case 1:
		pss->_sstop1 -= 2;
		break;
	case 2:
		pss->_sstop2 -= 2;
		break;
	default:
		break;
	}
}

_SSDataType TopShareStack(ShareStack * pss, int which)
{
	assert(pss && (which == 1 || which == 2));
	switch (which)
	{
	case 1:
		return pss->_ssa[pss->_sstop1 - 2];
		break;
	case 2:
		return pss->_ssa[pss->_sstop2 - 2];
		break;
	default:
		break;
	}
}

int isEmptyShareStack(ShareStack * pss, int which)
{
	assert(pss && (which == 1 || which == 2));
	switch (which)
	{
	case 1:
		return pss->_sstop1 == 0 ? 0 : 1;
		break;
	case 2:
		return pss->_sstop2 == 1 ? 0 : 1;
		break;
	default:
		break;
	}
}

int SizeShareStack(ShareStack * pss, int which)
{
	assert(pss && (which == 1 || which == 2));
	switch (which)
	{
	case 1:
		return pss->_sstop1 / 2;
		break;
	case 2:
		return pss->_sstop2 / 2;
		break;
	default:
		break;
	}
}

以上三个实例的测试代码

Test.c

void testMinStack()
{
	MinStack ms;
	InitMinStack(&ms);
	PushMinStack(&ms, 1);
	PushMinStack(&ms, 4);
	PushMinStack(&ms, 0);
	PushMinStack(&ms, 0);
	PushMinStack(&ms, 8);
	PushMinStack(&ms, 0);
	printf("%d\n", TopMinStack(&ms));
	PopMinStack(&ms);
	printf("%d\n", TopMinStack(&ms));
	PopMinStack(&ms);
	printf("%d\n", TopMinStack(&ms));
	PopMinStack(&ms);
	printf("%d\n", TopMinStack(&ms));
	PopMinStack(&ms);
	printf("%d\n", TopMinStack(&ms));
	PopMinStack(&ms);
	printf("%d\n", TopMinStack(&ms));
	PopMinStack(&ms);
	DestoryMinStack(&ms);
}

void testIsLegalStackOrder()
{
	int in[] = { 1,2,3,4,5 };
	int out[] = { 5,4,3,2,1 };
	int sz_in = sizeof(in) / sizeof(in[0]);
	int sz_out = sizeof(out) / sizeof(out[0]);
	printf("%d\n", IsLegalStackOrder(in, sz_in, out, sz_out));
}

void testShareStack()
{
	ShareStack ss;
	InitShareStack(&ss);

	PushShareStack(&ss, 1, 1);
	PushShareStack(&ss, 2, 2);
	PushShareStack(&ss, 3, 1);
	PushShareStack(&ss, 4, 2);
	PushShareStack(&ss, 5, 1);
	PushShareStack(&ss, 6, 2);
	PushShareStack(&ss, 7, 1);
	PushShareStack(&ss, 8, 2);
	PushShareStack(&ss, 9, 1);
	PushShareStack(&ss, 0, 2);

	printf("1号栈:[%d]::[%d]\n", isEmptyShareStack(&ss, 1), SizeShareStack(&ss ,1));
	printf("%d ", TopShareStack(&ss, 1));
	PopShareStack(&ss, 1);
	printf("%d ", TopShareStack(&ss, 1));
	PopShareStack(&ss, 1);
	printf("%d ", TopShareStack(&ss, 1));
	PopShareStack(&ss, 1);
	printf("%d ", TopShareStack(&ss, 1));
	PopShareStack(&ss, 1);
	printf("%d ", TopShareStack(&ss, 1));
	PopShareStack(&ss, 1);
	printf("\n1号栈:[%d]::[%d]\n", isEmptyShareStack(&ss, 1), SizeShareStack(&ss, 1));

	printf("\n2号栈:[%d]::[%d]\n", isEmptyShareStack(&ss, 2), SizeShareStack(&ss, 2));
	printf("%d ", TopShareStack(&ss, 2));
	PopShareStack(&ss, 2);
	printf("%d ", TopShareStack(&ss, 2));
	PopShareStack(&ss, 2);
	printf("%d ", TopShareStack(&ss, 2));
	PopShareStack(&ss, 2);
	printf("%d ", TopShareStack(&ss, 2));
	PopShareStack(&ss, 2);
	printf("%d ", TopShareStack(&ss, 2));
	PopShareStack(&ss, 2);
	printf("\n2号栈:[%d]::[%d]\n", isEmptyShareStack(&ss, 2), SizeShareStack(&ss, 2));

	DestoryShareStack(&ss);
}