程序员修仙之路-数据结构之 CXO让我作一个计算器！！
CXO的需求果真还在继续，深呼吸，深呼吸 .......golang
有人说数据结构是为算法服务的，我还要在加一句：数据结构和算法都是为业务服务的！！算法
CXO的需求果真不一样凡响，又让菜菜想到了新的数据结构：栈c#
栈的特性
定义
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅容许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另外一端称为栈底。向一个栈插入新元素又称做进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称做出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。数组
栈做为一种数据结构,其中有几个特性须要提起你们注意：bash
- 操做受限：何为操做受限？在栈的操做中，通常语言中针对栈的操做只有两种：入栈和出栈。而且操做只发生在栈的顶部。 有的同窗会问，我用其余数据结构也同样能实现栈的效果。不错，可是每种数据结构都有本身的使用场景，没有一种绝对无用的数据结构。
- 栈在数据结构上属于一种线性表，知足后进先出的原则。这也是栈的最大特性，几乎大部分后进先出的场景均可以使用栈这个容器。好比一个函数的调用过程当中，局部变量的存储就是栈原理。当执行一个函数结束的时候，局部变量其实最早释放的是最后的局部变量。
实现
在内存分布上栈是用是实现的呢？既然栈是一种线性结构，也就说能够用线性的内存分布数据结构来实现。数据结构
- 数组实现栈（顺序栈）：数组是在内存分布上连续的一种数据结构。通过之前的学习，咱们知道数组的容量是不变的。若是业务上能够知道一个栈的元素的最大数量，咱们彻底能够用数组来实现。为何这么说？由于数组的扩容在某些时候性能是比较低的。由于须要开辟新空间，并发生复制过程。
class MyStack
{
//数组容器
int[] container = new int[100];
//栈顶元素的索引
int TopIndex = -1;
//入栈操做
public void Push(int newValue)
{
if (TopIndex >= 99)
{
return ;
}
TopIndex++;
container[TopIndex] = newValue;
}
//出栈操做
public int Pop()
{
if (TopIndex < 0)
{
return 0;
}
var topValue = container[TopIndex];
TopIndex--;
return topValue;
}
}
复制代码
- 链表实现栈（链式栈）：为了应对数组的扩容问题，咱们能够用链表来实现栈。栈的顶部元素永远指向链表的头元素便可。具体代码有兴趣的同窗能够实现一下。
由以上能够看出，栈实际上是基于基础数据结构之上的一个具体业务形式的封装即：先进后出。并发
性能
基于数组的栈咱们暂且只讨论未发生数组重建的场景下。不管是数组实现仍是链表实现，咱们发现栈的内部实际上是有一个指向栈顶元素的指针，不会发生遍历数组或者链表的情形，因此栈的出栈操做时间复杂度为O（1）。至于入栈，若是你看过我之前介绍数组和链表的文章，你能够知道，给一个数组下标元素赋值的操做时间复杂度为O（1），在链表头部添加一个元素的操做时间复杂度也是O（1）。因此不管是数组仍是链表实现栈，入栈操做时间复杂度也是O（1）。而且栈只有入栈出栈两种操做，比其余数据结构有N个操做方法要简单不少，也不容易出错。 至于发生数组重建，copy所有数据的过程实际上是一个顺序栈最坏的时间复杂度，由于和原数组的元素个数n有关，因此时间复杂度为O（n）app
设计要点
那一个计算器怎么用栈来实现呢？其实不少编译器就是经过两个栈来实现的，其中一个栈保存操做的数，另外一个栈保存运算符。 咱们从左到右遍历表达式，当遇到数字，咱们直接压入操做数栈；当遇到操做符的时候，当前操做符与操做符栈顶的元素比较优先级（先乘除后加减的原则） 。若是当前运算符比栈顶运算符优先级高，那说明不须要执行栈顶运算符运算，咱们直接将当前运算符也入栈； 若是当前运算符比栈顶运算符优先级低，那说明该执行栈顶运算符的运算了。 而后出栈运算符栈顶元素，数据栈顶两个元素，而后进行相关运算，而后把运算结果再次压入数据栈。数据结构和算法
来一发吧
代码写的通常主要是演示栈的应用，特殊状况下计算结果可能有误，有兴趣的同窗能够重构一下函数
c# 版本
class Program
{
static void Main(string[] args)
{
List<string> lstAllData = new List<string>();
//读取输入的表达式，并整理
string inputStr = Console.ReadLine();
string tempData = "";
for (int i = 0; i < inputStr.Length; i++)
{
if (inputStr[i] == '+' || inputStr[i] == '-' || inputStr[i] == '*' || inputStr[i] == '/')
{
lstAllData.Add(tempData);
lstAllData.Add(inputStr[i].ToString());
tempData = "";
}
else
{
tempData += inputStr[i];
}
if(i== inputStr.Length - 1)
{
lstAllData.Add(tempData);
}
}
foreach (var item in lstAllData)
{
Calculator.Cal(item.ToString());
}
var ret = Calculator.GetResult();
Console.WriteLine(ret);
Console.Read();
}
}
//计算器
class Calculator
{
//存放计算数据的栈
static Stack<int> DataStack = new Stack<int>();
//存放操做符的栈
static Stack<string> OperatorStack = new Stack<string>();
public static int Cal(string dataOrOperator)
{
int data;
bool isData = int.TryParse(dataOrOperator, out data);
if (isData)
{
//若是是数据直接入数据栈
DataStack.Push(data);
}
else
{
//若是是操做符，和栈顶操做符比较优先级，若是大于栈顶，则直接入栈，不然栈顶元素出栈 进行操做
if (OperatorStack.Count <= 0)
{
OperatorStack.Push(dataOrOperator);
}
else
{
//当前运算符的优先级
var currentOpePrecedence = OperatorPrecedence(dataOrOperator);
//当前运算符栈顶元素的优先级
var stackTopOpePrecedence = OperatorPrecedence(OperatorStack.Peek());
if (currentOpePrecedence > stackTopOpePrecedence)
{
//若是当前运算符的优先级大于栈顶元素的优先级，则入栈
OperatorStack.Push(dataOrOperator);
}
else
{
//运算符栈顶元素出栈，数据栈出栈两个元素，而后进行运算
var stackOpe = OperatorStack.Pop();
var data2 = DataStack.Pop();
var data1 = DataStack.Pop();
var ret = CalculateData(stackOpe, data1, data2);
DataStack.Push(ret);
OperatorStack.Push(dataOrOperator);
}
}
}
return 0;
}
//获取表达式最后的计算结果
public static int GetResult()
{
var ret = 0;
while (OperatorStack.Count > 0)
{
var stackOpe = OperatorStack.Pop();
var data2 = DataStack.Pop();
var data1 = DataStack.Pop();
ret = CalculateData(stackOpe, data1, data2);
DataStack.Push(ret);
}
return ret;
}
//根据操做符进行运算，这里能够抽象出接口，请自行实现
static int CalculateData(string operatorString, int data1, int data2)
{
switch (operatorString)
{
case "+":
return data1 + data2;
case "-":
return data1 - data2;
case "*":
return data1 * data2;
case "/":
return data1 + data2;
default:
return 0;
}
}
//获取运算符优先级
public static int OperatorPrecedence(string a) //操做符优先级
{
int i = 0;
switch (a)
{
case "+": i = 1; break;
case "-": i = 1; break;
case "*": i = 2; break;
case "/": i = 2; break;
}
return i;
}
}
复制代码
运行结果：
10+20*3+10-10+20-20+60*2
190
复制代码
golang版本
package stack
import (
"errors"
"fmt"
)
type Stack struct {
Element []interface{} //Element
}
func NewStack() *Stack {
return &Stack{}
}
func (stack *Stack) Push(value ...interface{}) {
stack.Element = append(stack.Element, value...)
}
//返回下一个元素
func (stack *Stack) Top() (value interface{}) {
if stack.Size() > 0 {
return stack.Element[stack.Size()-1]
}
return nil //read empty stack
}
//返回下一个元素,并从Stack移除元素
func (stack *Stack) Pop() (value interface{}) {
if stack.Size() > 0 {
d := stack.Element[stack.Size()-1]
stack.Element = stack.Element[:stack.Size()-1]
return d
}
return nil
}
//交换值
func (stack *Stack) Swap(other *Stack) {
switch {
case stack.Size() == 0 && other.Size() == 0:
return
case other.Size() == 0:
other.Element = stack.Element[:stack.Size()]
stack.Element = nil
case stack.Size() == 0:
stack.Element = other.Element
other.Element = nil
default:
stack.Element, other.Element = other.Element, stack.Element
}
return
}
//修改指定索引的元素
func (stack *Stack) Set(idx int, value interface{}) (err error) {
if idx >= 0 && stack.Size() > 0 && stack.Size() > idx {
stack.Element[idx] = value
return nil
}
return errors.New("Set失败!")
}
//返回指定索引的元素
func (stack *Stack) Get(idx int) (value interface{}) {
if idx >= 0 && stack.Size() > 0 && stack.Size() > idx {
return stack.Element[idx]
}
return nil //read empty stack
}
//Stack的size
func (stack *Stack) Size() int {
return len(stack.Element)
}
//是否为空
func (stack *Stack) Empty() bool {
if stack.Element == nil || stack.Size() == 0 {
return true
}
return false
}
//打印
func (stack *Stack) Print() {
for i := len(stack.Element) - 1; i >= 0; i-- {
fmt.Println(i, "=>", stack.Element[i])
}
}
package calculator
import (
"calculator/stack"
"strconv"
)
type Calculator struct{}
var DataStack *stack.Stack
var OperatorStack *stack.Stack
func NewCalculator() *Calculator {
DataStack = stack.NewStack()
OperatorStack = stack.NewStack()
return &Calculator{}
}
func (c *Calculator) Cal(dataOrOperator string) int {
if data, ok := strconv.ParseInt(dataOrOperator, 10, 64); ok == nil {
//若是是数据直接入数据栈
// fmt.Println(dataOrOperator)
DataStack.Push(data)
} else {
//若是是操做符，和栈顶操做符比较优先级，若是大于栈顶，则直接入栈，不然栈顶元素出栈 进行操做
if OperatorStack.Size() <= 0 {
OperatorStack.Push(dataOrOperator)
} else {
//当前运算符的优先级
currentOpePrecedence := operatorPrecedence(dataOrOperator)
//当前运算符栈顶元素的优先级
stackTopOpePrecedence := operatorPrecedence(OperatorStack.Top().(string))
if currentOpePrecedence > stackTopOpePrecedence {
//若是当前运算符的优先级大于栈顶元素的优先级，则入栈
OperatorStack.Push(dataOrOperator)
} else {
//运算符栈顶元素出栈，数据栈出栈两个元素，而后进行运算
stackOpe := OperatorStack.Pop()
data2 := DataStack.Pop()
data1 := DataStack.Pop()
ret := calculateData(stackOpe.(string), data1.(int64), data2.(int64))
DataStack.Push(ret)
OperatorStack.Push(dataOrOperator)
}
}
}
return 0
}
func (c *Calculator) GetResult() int64 {
var ret int64
for {
if OperatorStack.Size() > 0 {
stackOpe := OperatorStack.Pop()
data2 := DataStack.Pop()
data1 := DataStack.Pop()
ret = calculateData(stackOpe.(string), data1.(int64), data2.(int64))
DataStack.Push(ret)
} else {
break
}
}
return ret
}
func calculateData(operatorString string, data1, data2 int64) int64 {
switch operatorString {
case "+":
return data1 + data2
case "-":
return data1 - data2
case "*":
return data1 * data2
case "/":
return data1 + data2
default:
return 0
}
}
func operatorPrecedence(a string) int {
i := 0
switch a {
case "+":
i = 1
case "-":
i = 1
case "*":
i = 2
case "/":
i = 2
}
return i
}
package main
import (
"calculator/calculator"
"flag"
"fmt"
)
var (
inputStr = flag.String("input", "", "请输入...")
)
func main() {
flag.Parse()
var lstAllData []string
var tempData string
rs := []rune(*inputStr)
for i := 0; i < len(rs); i++ {
if string(rs[i]) == "+" || string(rs[i]) == "-" || string(rs[i]) == "*" || string(rs[i]) == "/" {
lstAllData = append(lstAllData, tempData)
lstAllData = append(lstAllData, string(rs[i]))
tempData = ""
} else {
tempData += string(rs[i])
}
if i == len(rs)-1 {
lstAllData = append(lstAllData, tempData)
}
}
ca := calculator.NewCalculator()
for _, v := range lstAllData {
ca.Cal(v)
}
ret := ca.GetResult()
fmt.Println(ret)
}
复制代码
运算结果：
go run program.go -input=1+2-1*3
结果：0
复制代码
添加关注，查看更精美版本，收获更多精彩
相关文章
- 1. 程序员修仙之路-数据结构之设计一个高性能线程池
- 2. 程序猿修仙之路--数据结构之你是否真的懂数组？
- 3. 程序员修仙之路--高性能排序多个文件
- 4. 程序员的修仙之路-筑基篇
- 5. 程序猿修仙之路--算法之希尔排序
- 6. 程序员修炼之路
- 7. 成为出色的程序员必修之路-数据结构（总结）
- 8. 程序员架构师修行之路
- 9. LazyCoder修仙之路
- 10. 算法工程师修仙之路：机器学习实战（一）
- 更多相关文章...
- • C# 程序结构 - C#教程
- • 第一个MyBatis程序 - MyBatis教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
- • 算法总结-归并排序
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章