什么是栈？
栈是限制插入和删除只能在同一个位置上进行的表，这个位置就是栈的顶端，对于栈的操作主要有三种形式：入栈(将元素插入到表中)，出栈(将表最后的元素删除，也就是栈顶的元素)，返回栈顶元素。栈有时又叫LIFO(后进先出)表。
栈的实现
栈可以有两种实现方式：1）数组实现 2）链表实现
栈的双向链表实现
public class StackForLinked<T>
{
private int num = 0;
public int count { get{return num;} }
private Node<T> root = null;
private class Node<T>
{
public T data;
public Node<T> prev;
public Node<T> next;
public Node(T value)
{
this.data = value;
this.prev=null;
this.next=null;
}
public Node(T value,Node<T> prev,Node<T> next):this(value)
{
this.prev = prev;
this.next=next;
}
}
public void Push(T value)
{
Node<T> node = new Node<T>(value);
if(root==null)
{
root = node;
}
else
{
var last= GetLastNode();
last.next = node;
node.prev= last;
}
num++;
}
public T Pop()
{
var node=GetLastNode();
if(node==null)
throw new Exception();
node.prev.next=null;
num--;
return node.data;
}
public T GetTop()
{
var node =GetLastNode();
if(node==null)
throw new Exception();
return node.data;
}
private Node<T> GetLastNode()
{
Node<T> p = root;
if(root==null)
{
return null;
}
while(true)
{
if(p.next!=null)
{
p=p.next;
}
else
break;
}
return p;
}
}栈的数组实现
public class StackForArray<T>
{
private static int length = 100;
private T[] objList = new T[length];
private int currentIndex = 0；
public int count { get { return this.currentIndex;} }
private void ensureCapcity(int capcity)
{
if(capcity < currentIndex)
{
return;
}
T[] old = objList;
objList = new T[capcity];
for(int i=0;i<old.Length;i++)
{
objList[i] = old[i];
}
}
public void Push(T value)
{
if(currentIndex == length)
{
ensureCapcity(currentIndex * 2 +1);
}
objList[currentIndex] = value;
currentIndex++;
}
public T Pop()
{
if(currentIndex == 0)
throw new Exception();
currentIndex--;
return objList[currentIndex];
}
public T GetTop()
{
if(currentIndex == 0)
{
throw new Exception();
}
return objList[currentIndex -1];
}
}PS：对于链表在添加和删除方面是O(1), 但是在查找方面则是O(N)；数组在查找方面是O(1)操作,但是在插入或者是删除方面涉及到表的中元素的位置上的移动，若数据中的元素较多会带来性能上的损失。所以在考虑使用链表还是使用数组进行存储数据的时候，应该考虑上述所说(数据量大小，插入和删除多还是查找的多)。当前这与栈的关系不太大，因为栈都是在一端进行操作，不会涉及元素移动的问题。
栈的应用
栈的应用有很多，这里只举一些简单的例子：
1.平衡符号：例如判断括号是否成对出现，通过将括号入栈然后碰见成对的括号就出栈，最后判断栈中的元素是否为空，为空则是成对出现，反之则不成对
2.中缀表达式转化为后缀表达式：
中缀表达式和后缀表达式: 例如表达式 a + b * c 这就是我们平时所见的正常的数学计算表达式，在数学上我们也知道怎么计算，但是你把这一段表达式告诉计算机，然后计算出结果，那么这个结果是怎么计算出来的呢？这里就涉及一个概念叫做后缀表达式，首先 a + b * c 会先通过栈转化为 a b c * + 然后再通过栈进行计算从而得出结果，前者通常叫做中缀表达式。随后会有一段代码的例子，可以让你真正的了解数学表达式是如何通过栈进行计算的
3.方法调用：类似于平衡符号的检测，所有的方法调用和返回都是成对的，在开始调用的时候需要在栈内存储一些信息(位置,对应变量的名字和返回地址等)，方法完成后需要从栈中出栈拿到当初存储的信息然后做一些操作,这也正好印证了，当递归调用的时候，不当的递归会出现 Stackoverflow 异常，也就是说在栈(在window下，默认大小是1M )中已经存储不下每一次递归的信息了，就会报这个错误。
PS： 我这里说的都是同步方法，存在一个方法的调用需要等待另一个方法的完成，异步方法还不太了解，期待后续学习会有更多的收获
栈实现基本操作的运算
用栈来实现简单的基本数学运算：+ ，- ，* ， ／ 和（ ）在数学中我们都知道这几种符号的优先级，那么计算机时怎么做到的呢？ 下面我们以一个表达式为例子来实现一下计算机的计算过程
表达式：a + b * c + ( d * e + f ) * g ，除栈外，我们还需要一个输出字符串用来存储生成的后缀表达式，默认情况下为空，出于方便我会使用 [] 代表一个栈，[ 代表栈底，] 代表栈顶，用 | 分割每个元素。
原理
1.对常数输出，对操作符号入栈操作，根据优先级别判断是出栈还是入栈；
2.优先级低的不允许出现在优先级高的后面(栈中存在一个优先级高的符号，此时来了一个低优先级符号，需要进行先把高优先级的符号出栈，然后将低优先级的符号入栈)；
3.同优先级的符号先出栈再入栈；
4.对于存在括号的情况，当前栈顶的元素是 ( 那么接下来的一个符号不比较优先级直接入栈，接下来的操作遵循前3条规则;
5.当遇见 ）的时候，执行出栈操作直到遇见出栈的第一个（ 为止；
6.得到后缀表达式之后再次使用栈进行计算，将后缀表达式中的值入栈，碰见操作符，出栈两个元素执行运算符计算，将计算的结果插入到栈中，直到后缀表达式的尽头，最终结果位于栈顶，出栈即可得到
步骤：
1.将中缀表达式转化为后缀表达式
Step 1 : 我们第一次读取的是常数 a ，直接输出，此时输出的字符串中的值为 a
Step 2 : 继续读取，接下来读取的是操作符号 + ，入栈操作，此时栈中的元素为 [ + ]
Step 3 : 继续读取，接下来读取的是常数 b , 直接输出，此时输出的字符串中的值为 a b
Step 4 : 继续读取，接下来读取的是操作符号 * , 入栈操作，此时栈中的元素为 [ + | * ]
Step 5 : 继续读取，接下来读取的是常数 c , 直接输出，此时输出的字符串中的值为 a b c
Step 6 : 继续读取，接下来读取的是操作符号 + , 栈顶元素 * 的优先级高于 + ，将 * 出栈，之后发现栈顶元素为 +，优先级相同，继续出栈，然后将 + 进栈，此时栈中的元素为[ + ]，输出字符串中的值为 a b c * +
Step 7 : 继续读取，接下来读取的是操作符号 ( , 入栈操作，此时栈中的元素为 [ + | ( ]
Step 8 : 继续读取，接下来读取的是常数 d , 直接输出，此时输出的字符串中的值为 a b c * + d
Step 9 : 继续读取，接下来读取的是操作符号 * , 入栈操作，此时栈中的元素为[ + | ( | * ]
Step 10 : 继续读取，接下来读取的是常数 e , 直接输出，此时输出的字符串中的值为 a b c * + d e
Step 11 : 继续读取，接下来读取的是操作符号 + , 栈顶元素 * 的优先级高于 + ，先执行出栈操作，在执行 + 入栈操作，此时栈中的元素为[ + | ( | +] , 输出字符串中的值为 a b c * + d e *
Step 12 : 继续读取，接下来读取的是常数 f , 直接输出，此时输出的字符串中的值为 a b c * + d e * f
Step 13 : 继续读取，接下来读取的是操作符号 ) , 开始执行出栈操作，直到遇见第一个出栈的元素为 ( 停止，此时栈中的元素为[ + ] , 输出字符串中的值为 a b c * + d e * +
Step 14 : 继续读取，接下来读取的是操作符号 * , 入栈操作，此时栈中的元素为[ + | * ]
Step 15 : 继续读取，接下来读取的是常数 g , 直接输出，此时输出的字符串中的值为 a b c * + d e * f + g
Step 16: 继续读取，到达了末端，开始执行中出栈操作，直到栈为空，此时输出的字符串中的值为 a b c * + d e * f + g * + ，从而得出后缀表达式为：a b c * + d e * f + g * +
2.计算后缀表达式 (Step中的括号的使用是起到辅助清晰的作用，因为并没给字符实际的值)
Step 1 : 读取后缀表达式，第一个遇到的是 a 执行入栈操作，此时栈中的元素为 [ a ]
Step 2 : 继续读取，解下来遇到的是 b ，执行入栈操作，此时栈中的元素为 [ a | b ]
Step 3 : 继续读取，解下来遇到的是 c ，执行入栈操作，此时栈中的元素为 [ a | b | c ]
Step 4 : 继续读取，解下来遇到的是 * ，出栈两个元素，计算 b * c ，然后在执行入栈， 此时栈中的元素为 [ a | b * c ]
Step 5 : 继续读取，解下来遇到的是 + ，出栈两个元素，计算 a + b * c，然后执行入栈操作，此时栈中的元素为 [ a + b * c ]
Step 6 : 继续读取，解下来遇到的是 d ，执行入栈操作，此时栈中的元素为 [ a + b * c | d ]
Step 7 : 继续读取，解下来遇到的是 e ，执行入栈操作，此时栈中的元素为 [ a + b * c | d | e ]
Step 8 : 继续读取，解下来遇到的是 * ，出栈两个元素，计算 d * e ，然后执行入栈操作，此时栈中的元素为 [ a + b * c | d * e ]
Step 9 : 继续读取，解下来遇到的是 f ，执行入栈操作，此时栈中的元素为 [ a + b * c | d * e | f ]
Step 10 : 继续读取，解下来遇到的是 + ，出栈两个元素，计算 d * e + f ，然后执行入栈操作，此时栈中的元素为 [ a + b * c | d * e + f ]
Step 11 : 继续读取，解下来遇到的是 g ，执行入栈操作，此时栈中的元素为 [ a + b * c | d * e + f | g ]
Step 12 : 继续读取，解下来遇到的是 * ，出栈两个元素，计算 ( d * e + f ) * g ，然后执行入栈操作，此时栈中的元素为 [ a + b * c | ( d * e + f ) * g ]
Step 13 : 继续读取，解下来遇到的是 + ，出栈两个元素，计算 a + b * c + ( d * e + f ) * g ，然后执行入栈操作，此时栈中的元素为 [ a + b * c + ( d * e + f ) * g ]
Step 14 : 继续读取，到达了末端，执行出栈操作，出栈的结果就是计算的结果 a + b * c + ( d * e + f ) * g
实现代码
class Program
{
static List<Priority> priority = new List<Priority>()
{
new Priority() { level = 0 , symbal ="+" },
new Priority() { level = 0 , symbal ="-" },
new Priority() { level = 1 , symbal ="*" },
new Priority() { level = 1 , symbal ="/" },
new Priority() { level = int.MaxValue , symbal ="(" },
new Priority() { level = int.MaxValue , symbal =")" }
};
static void Main(string[] args)
{
//string expression = "a + b * c + ( d * e + f ) * g";
//string expression ="10 + 1 * 10 + ( 2 * 3 + 4 ) * 10"; // 120
//string expression ="1 + 2 + 3 ";
string expression ="3 * ( ( 2 - 4 ) / ( 2 - 1 ) ) ";
GenerateExpression(expression);
Console.WriteLine(OutputStr);
Console.WriteLine(CalculateValue());
}
///生成后缀表达式的栈
static StackForArray<Priority> symbalStack = new StackForArray<Priority>();
/// 输出字符串
static string OutputStr=string.Empty;
/// 生成后缀表达式
static void GenerateExpression(string expression)
{
string[] symbals = expression.Split(' ');
foreach(string symbal in symbals)
{
RecursionExpression(symbal);
}
while(true)
{
try
{
var popElement = symbalStack.Pop();
OutputStr += popElement.symbal +" ";
}
catch(Exception ex)
{
break;
}
}
}
// 计算表达式的值
static int CalculateValue()
{
StackForArray<int> valueStack = new StackForArray<int>();
string[] symbals = OutputStr.Split(new char[]{' '}
,StringSplitOptions.RemoveEmptyEntries);
foreach(var symbal in symbals)
{
var temp = priority.Where(x=>x.symbal ==symbal).FirstOrDefault();
if(temp!=null)
{
var t = 0;
var second = valueStack.Pop();
var first = valueStack.Pop();
switch (symbal)
{
case "*":
t = first * second;
break;
case "/":
t = first / second;
break;
case "+":
t = first + second;
break;
case "-":
t = first - second;
break;
default:
throw new Exception();
}
valueStack.Push(t);
}
else
{
valueStack.Push(int.Parse(symbal));
}
}
return valueStack.Pop();
}
/// 递归表达式
static void RecursionExpression(string symbal)
{
var temp = priority.Where(x=>x.symbal == symbal).FirstOrDefault();
if(temp==null)
{
OutputStr+= symbal + " ";
return;
}
var stackCount = symbalStack.count;
if(stackCount==0 || temp.symbal =="(")
{
symbalStack.Push(temp);
return;
}
if(temp.symbal ==")")
{
while(true)
{
var popElement = symbalStack.Pop();
OutputStr += popElement.symbal +" ";
if(popElement.symbal=="(")
{
OutputStr=OutputStr.Substring(0,OutputStr.Length -2);
break;
}
}
return;
}
var topElement = symbalStack.GetTop();
if(temp.level > topElement.level || topElement.symbal=="(")
{
symbalStack.Push(temp);
return;
}
if(temp.level <= topElement.level && topElement.symbal != "(")
{
var popElement= symbalStack.Pop();
OutputStr += popElement.symbal +" ";
RecursionExpression(temp.symbal);
return;
}
}
}
public class Priority
{
public string symbal { get; set; }
public int level { get; set; }
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
