栈

关于栈，这里的定义和前面的顺序表是一样，采用数组的形式，详细请见: 顺序表

栈相关处理类代码：

	/// <summary>
	/// Description of SequenceStack.
	/// </summary>
	public class SequenceStack<T> where T:IComparable
	{
		private Sequence<T> _sequence;
		private int _size;
		public SequenceStack(int size)
		{
			_size=size;
			_sequence=new Sequence<T>(_size);
		}
		
		/// <summary>
		/// Init the sequence stack
		/// </summary>
		public void Init()
		{
			_sequence.Current=0;
		}
		
		/// <summary>
		/// Check whether the sequence stack is empty
		/// </summary>
		/// <returns>True or false</returns>
		public bool IsEmpty()
		{
			if(_sequence.Current==0)
			{
				Console.WriteLine("SequenceStack is empty!");
				return true;
			}
			return false;
		}
		
		/// <summary>
		/// Check whether the sequence stack is full
		/// </summary>
		/// <returns>True or false</returns>
		public bool IsFull()
		{
			if(_sequence.Current>=_sequence.Size) 
			{
				Console.WriteLine("SequenceStack is full!");
				return true;
			}
			return false;
		}
		
		/// <summary>
		/// Get the top value
		/// </summary>
		/// <returns>The top value</returns>
		public T GetTop()
		{
			if(IsEmpty()) return default(T);
			
			return _sequence.Data[_sequence.Current-1];
		}
		
		/// <summary>
		/// Push a value into the sequence stack
		/// </summary>
		/// <param name="x">the value want to be pushed</param>
		public void Push(T x)
		{
			if(IsFull()) return;
			
			_sequence.Data[_sequence.Current]=x;
			_sequence.Current++;
		}
		
		/// <summary>
		/// Pop a value from the sequence stack
		/// </summary>
		/// <returns>a value</returns>
		public T Pop()
		{
			if(IsEmpty()) return default(T);
			
			///Get the top value
			T result= GetTop();
			
			_sequence.Current--;
			return result;
		}
		
		/// <summary>
		/// Get the priority of a char
		/// </summary>
		/// <param name="op">the char</param>
		/// <returns></returns>
		public int GetPriority(char op)
		{
			switch(op)
			{
				case '#':
					{
						return -1;
					}
				case '(':
					{
						return 0;
					}
				case '+':
				case '-':
					{
						return 1;
					}
				case '*':
				case '/':
					{
						return 2;
					}
				default:
					{
						return -1;
					}
			}
		}
		
		/// <summary>
		/// Check a char whether is a operation
		/// </summary>
		/// <param name="op">The char want to be checked</param>
		/// <returns></returns>
		public bool IsOperation(char op)
		{
			switch(op)
			{
				case '+':
				case '-':
				case '*':
				case '/':
					return true;
				default:return false;
			}
		}
		
		/// <summary>
		/// Check a char array Whether is a brackets matched array
		/// </summary>
		/// <param name="s">The array need to be checked</param>
		/// <returns>Match or not</returns>
		public static bool MatchBrackets(char[] s)
		{
			SequenceStack<char> stack=new SequenceStack<char>(100);
			int i=0;
			while(s[i]!='#')
			{
				switch(s[i])
				{
					case '{':
					case '[':
					case '(':
						{
							stack.Push(s[i]);break;
						}
					case '}':
						{
							if(!stack.IsEmpty()&&stack.GetTop()=='{')
							{
								stack.Pop();break;
							}
							return false;
						}
					case ']':
						{
							if(!stack.IsEmpty()&&stack.GetTop()=='[')
							{
								stack.Pop();break;
							}
							return false;
						}
					case ')':
						{
							if(!stack.IsEmpty()&&stack.GetTop()=='(')
							{
								stack.Pop();break;
							}
							return false;
						}
				}
				i++;
			}
			return stack.IsEmpty();
		}
		
		/// <summary>
		/// Convert a char array to a double number
		/// </summary>
		/// <param name="s">The char array need to be converted</param>
		/// <param name="index">The start position</param>
		/// <param name="endIndex">The end position</param>
		/// <returns>the double number</returns>
		public static double ConvertNumber(char[] s,int index,out int endIndex)
		{
			double number=0.0d;
			while(s[index]>='0'&&s[index]<='9')
			{
				number=number*10+int.Parse(s[index].ToString());
				index++;
			}
			
			if(s[index]=='.')
			{
				int i=-1;
				index++;
				while(s[index]>='0'&&s[index]<='9')
				{
					number=number+int.Parse(s[index].ToString())*Math.Pow(10,i);
					index++;
					i--;
				}
			}
			endIndex=index;
			return number;
		}
		
		/// <summary>
		/// Get the value of a postfix expression
		/// </summary>
		/// <param name="s">The postfix expression</param>
		/// <returns>The value</returns>
		public static double GetPostfixValue(char[] s)
		{
			SequenceStack<double> stack=new SequenceStack<double>(100);
			double number1,number2;
			int i=0;
			while(s[i]!='#')
			{
				if(s[i]>='0'&&s[i]<='9')
				{
					stack.Push(ConvertNumber(s,i,out i));
					continue;
				}
				
				if(s[i]==' ') {i++;continue;}
				
				if(stack.IsOperation(s[i]))
				{
					number2=stack.Pop();
					number1=stack.Pop();
					switch(s[i])
					{
						case '+':
							{
								stack.Push(number1+number2);
								i++;
								break;
							}
						case '-':
							{
								stack.Push(number1-number2);
								i++;
								break;
							}
						case '*':
							{
								stack.Push(number1*number2);
								i++;
								break;
							}
						case '/':
							{
								stack.Push(number1/number2);
								i++;
								break;
							}
					}
				}
			}
			return stack.Pop();
		}
		
		/// <summary>
		/// Convert a infix expression to a postfix expression
		/// </summary>
		/// <param name="s">The infix expression</param>
		/// <returns>The postfix expression</returns>
		public static char[] ConvertPostfix(char[] s)
		{
			SequenceStack<char> stack=new SequenceStack<char>(100);
			char[] postfixArray=new char[100];
			int i=0,j=0;
			stack.Push('#');
			while(s[i]!='#')
			{
				if((s[i]>='0'&&s[i]<='9')||s[i]=='.')
				{
					postfixArray[j++]=s[i];
					i++;
					continue;
				}
				
				if(s[i]=='(')
				{
					stack.Push(s[i]);
					i++;
					continue;
				}
				
				if(s[i]==')')
				{
					char temp=stack.Pop();
					while(temp!='(')
					{
						postfixArray[j++]=temp;
						temp=stack.Pop();
					}
					i++;
					continue;
				}
				
				if(stack.IsOperation(s[i]))
				{
					postfixArray[j++]=' ';
					char temp=stack.Pop();
					while(stack.GetPriority(temp)>=stack.GetPriority(s[i]))
					{
						postfixArray[j++]=temp;
						temp=stack.Pop();
					}
					stack.Push(temp);
					stack.Push(s[i]);
					i++;
				}
			}
			
			while(stack._sequence.Current>0)
			{
				postfixArray[j++]=stack.Pop();
			}
			postfixArray[j++]=stack.Pop();
			return postfixArray;
		}
	}

为了验证各个功能是否能够良好运行，写一些代码测试一下：

#region test MatchBrackets method
			string matchTestString=@"2(2[3]j)3#";
			char[] matchTestArray=StringCommon.ConvertToArray(matchTestString);
			bool matchResult=SequenceStack<int>.MatchBrackets(matchTestArray);
			Console.WriteLine(matchResult);
			#endregion
			
			#region test ConvertNumber method
			string convertTestString=@"2312.012#";
			char[] convertTestArray=StringCommon.ConvertToArray(convertTestString);
			int index=0;
			double convertResult=SequenceStack<int>.ConvertNumber(convertTestArray,0,out index);
			Console.WriteLine("{0},{1}",convertResult,index);
			#endregion
			
			#region	test GetPostfixValue method
			string getPostfixValueTestString=@"3 5 2 *-#";
			char[] getPostfixValueTestArray=StringCommon.ConvertToArray(getPostfixValueTestString);
			double getResult=SequenceStack<int>.GetPostfixValue(getPostfixValueTestArray);
			Console.WriteLine("{0}",getResult);
			#endregion
			
			#region	test ConvertPostfix method
			string convertPostfixTestString=@"3*((30-2)+4*5/2)#";
			char[] convertPostfixTestArray=StringCommon.ConvertToArray(convertPostfixTestString);
			char[] convertPostfixResult=SequenceStack<int>.ConvertPostfix(convertPostfixTestArray);
			double gets=SequenceStack<int>.GetPostfixValue(convertPostfixResult);
			Console.WriteLine("{0}",gets);
			#endregion

在测试代码中，用到了类StringCommon，其代码如下：

/// <summary>
	/// Description of StringCommon.
	/// </summary>
	public class StringCommon
	{
		public StringCommon()
		{
		}
		
		/// <summary>
		/// Convert a string to a array
		/// </summary>
		/// <param name="s">The string need to be converted</param>
		/// <returns>Converted array</returns>
		public static char[] ConvertToArray(string s)
		{
			if(!IsEndWithChar(s,'#'))
			{
				throw new ApplicationException("The string is not end with '#'");
			}
			
			return s.ToCharArray();
		}
		
		/// <summary>
		/// Check a string whether is end with specified char
		/// </summary>
		/// <param name="c">The end with char</param>
		/// <returns>True or False</returns>
		public static bool IsEndWithChar(string s,char c)
		{
			return s[s.Length-1]==c?true:false;
		}
	}