数据结构_使用goto语句与栈实现 n! 的递归计算_使用了C++的模板类

数据结构_使用goto语句与栈实现 n! 的递归计算_使用了C++的模板类

Stack.h

#pragma once

#include "预定义.h"
#include <iostream>


#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

template<class SElemType>
struct SqStack
{
    SElemType* base, * top;
    int stacksize;
};

template<class SElemType>
Status InitStack(SqStack<SElemType> &S)
{
    S.base = (SElemType*) malloc(STACK_INIT_SIZE * sizeof(SElemType));
    if (!S.base)
        exit(OVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}

template<class SElemType>
Status DestroyStack(SqStack<SElemType> &S)
{
    if (!S.base)
        return ERROR;
    free(S.base);
    S.base = S.top = NULL;
    S.stacksize = 0;
    return OK;
}

template<class SElemType>
Status StackEmpty(SqStack<SElemType> S)
{
    if (S.top == S.base)
        return TRUE;
    return FALSE;
}

template<class SElemType>
Status GetTop(SqStack<SElemType> S, SElemType &e)
{
    if (S.top == S.base) return ERROR;
    e = *(S.top - 1);
    return OK;
}

template<class SElemType>
Status Push(SqStack<SElemType> &S, SElemType e)
{
    if (S.top - S.base >= S.stacksize)
    {
        //栈满, 追加存储空间
        S.base = (SElemType*) realloc(S.base,
                                      (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
        if (!S.base)
            exit(OVERFLOW);
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *S.top++ = e;  //记住此处是先取值后自加.
    return OK;
}

template<class SElemType>
Status Pop(SqStack<SElemType> &S, SElemType &e)
{
    if (S.top == S.base)
        return ERROR;
    e = *--S.top;
    return OK;
}

数据类型定义

typedef struct
{
	int rd;  //递归返回后执行的程序标号
	int n;  //本层参数
	int f;  //保存返回值用
} SElemType;

函数

int fact(int n)
{
	if (n == 0)  //对一种特殊情况的判断
		return 1;

	int f = 1;

	SElemType temp;
	SqStack<SElemType> S{};
	InitStack(S);
A:
	if (n == 0)
		f = 1;
	else
	{
		temp.rd = 'C', temp.n = n, temp.f = f;
B:
		Push(S, temp);
		n--;
		goto A;
C:
		f = n * f;
	}
	if (!StackEmpty(S))
	{
		(S.top - 1)->f = f;
		Pop(S, temp);
		n = temp.n + 1;
		//char a = temp.rd;
		goto C;
	}
	f = S.base->f;
	DestroyStack(S);
	return f;
}