golang 学习用数组模拟栈 参考

数组模拟栈操作 感觉有待节俭

package stackShed

type stack struct {
	maxNumber        int //栈的最大容量
	spliceStackFloat []float32
	spliceStackStr   []string
	stackType        byte //1为数字栈   其他位字符串栈
	stackTop         int  //栈顶初始化为-1
}

//创建一个栈 stackType：1为数字栈   其他位字符串栈
func CreateStack(stackType byte, maxNu int) stack {
	stResult := stack{
		maxNumber: maxNu,
		stackType: stackType,
		stackTop:  -1,
	}
	if stResult.stackType == 1 {
		stResult.spliceStackFloat = make([]float32, maxNu)
	} else {
		stResult.spliceStackStr = make([]string, maxNu)
	}

	return stResult
}

//数字入栈
func (its *stack) pushFloat(val float32) bool {
	bl := false
	if its.maxNumber == its.stackTop+1 {
		return bl
	} else if its.stackType == 1 {
		its.stackTop++
		its.spliceStackFloat[its.stackTop] = val
		bl = true
	}
	return bl
}

//字符串入栈
func (its *stack) pushStr(val string) bool {
	bl := false
	if its.maxNumber == its.stackTop+1 {
		return bl
	} else if its.stackType != 1 {
		its.stackTop++
		its.spliceStackStr[its.stackTop] = val
		bl = true
	}
	return bl
}

//数据入栈
func (its *stack) Push(val interface{}) bool {
	//根据站类型转化数据
	var valFloat float32
	// 感觉用这种方式进行类型推断不太好，能否用反射减少代码量
	switch val.(type) {
	case string:
		valStr, ok := val.(string)
		if !ok {
			return false
		}
		return its.pushStr(valStr)
	case int:
		valFloat = float32(val.(int))
	case int16:
		valFloat = float32(val.(int16))
	case float32:
		valFloat = val.(float32)
	case float64:
		valFloat = float32(val.(float64))
	case uint:
		valFloat = float32(val.(uint))
	case uint8:
		valFloat = float32(val.(uint8))
	case uint16:
		valFloat = float32(val.(uint16))
	case uint32:
		valFloat = float32(val.(uint32))
	default:
		return false
	}
	return its.pushFloat(valFloat)
}

//数据出栈
func (its *stack) Pop() (interface{}, bool) {
	var result interface{}
	var resBl bool = false
	if its.stackTop != -1 {
		if its.stackType == 1 {
			if its.spliceStackFloat == nil {
				return result, resBl
			}
			result = its.spliceStackFloat[its.stackTop]
			its.stackTop--
			resBl = true
		} else {
			if its.spliceStackStr == nil {
				return result, resBl
			}
			result = its.spliceStackStr[its.stackTop]
			its.stackTop--
			resBl = true
		}
	}
	return result, resBl
}

//看一下栈顶的数值，不是弹出数据
func (its *stack) LookTopVal() (interface{}, bool) {
	val, bl := its.Pop()
	if bl{
		its.stackTop++
	}
	return val, bl
}

//获取到当前栈的切片信息 返回结果只可能是[]float32 或者[]string 或者nil 的切片信息
func (its *stack) GetStackInfo() interface{} {
	var topNu = its.stackTop
	if topNu == -1 {
		return nil
	}
	var resVal interface{}
	if its.stackType == 1 {
		sliceInt := make([]float32, topNu+1)

		for idx := 0; idx <= topNu; idx++ {
			sliceInt[idx] = its.spliceStackFloat[topNu-idx]
		}
		resVal = sliceInt
	} else {
		sliceStr := make([]string, topNu+1)
		for idx := 0; idx <= topNu; idx++ {
			sliceStr[idx] = its.spliceStackStr[topNu-idx]
		}
		resVal = sliceStr
	}
	return resVal
}