算法系列15天速成——第十天 栈

算法系列15天速成——第十天 栈

转自：http://blog.csdn.net/m13666368773/article/details/7530238

今天跟大家聊聊栈，在程序设计中，栈的使用还是非常广泛的，比如有“括号匹配问题“，”html结构匹配问题“。

所以说掌握了”栈“的使用，对我们学习算法还是很有帮助的。

 

一： 概念

         栈，同样是一种特殊的线性表，是一种Last In First Out（LIFO)的形式，现实中有很多这样的例子，

     比如：食堂中的一叠盘子，我们只能从顶端一个一个的取。

 

二：存储结构

        ”栈“不像”队列“，需要两个指针来维护，栈只需要一个指针就够了，这得益于栈是一种一端受限的线性表。

      这里同样用”顺序结构“来存储这个”栈“，top指针指向栈顶，所有的操作只能在top处。

         

代码段：

[csharp]  view plain  copy

1. #region 栈的数据结构  
2.      /// <summary>  
3.  /// 栈的数据结构  
4.  /// </summary>  
5.      public class SeqStack<T>  
6.      {  
7.          public T[] data;  
8.    
9.          /// <summary>  
10.  /// 栈顶指针  
11.  /// </summary>  
12.          public int top = -1;  
13.    
14.          public SeqStack(int lenth)  
15.          {  
16.              data = new T[lenth];  
17.          }  
18.      }  
19.      #endregion  

 

三：常用操作

        栈的操作有：①初始化栈，②入栈，③出栈，④获取栈顶。

 

1: 初始化栈

        这个还是比较简单的，初始化栈时，设置默认top指针为-1，这个就不用图来展示了。

 

代码段：

[csharp]  view plain  copy

1. #region 栈的初始化操作  
2.          /// <summary>  
3.  /// 栈的初始化操作  
4.  /// </summary>  
5.  /// <typeparam name="T"></typeparam>  
6.  /// <returns></returns>  
7.          public SeqStack<T> SeqStackInit<T>(int length)  
8.          {  
9.              SeqStack<T> seqStack = new SeqStack<T>(length);  
10.    
11.              seqStack.top = -1;  
12.    
13.              return seqStack;  
14.          }  
15.          #endregion  

2：入栈

       这个操作主要就是做两件事情：① 将元素从栈顶压入，② top指针自增。

代码段：

[csharp]  view plain  copy

1. #region 入栈  
2.          /// <summary>  
3.  /// 入栈  
4.  /// </summary>  
5.  /// <typeparam name="T"></typeparam>  
6.  /// <param name="seqStack"></param>  
7.  /// <param name="data"></param>  
8.          public void SeqStackPush<T>(SeqStack<T> seqStack, T data)  
9.          {  
10.              if (SeqStackIsFull(seqStack))  
11.                  throw new Exception("不好意思，栈溢出");  
12.    
13.              seqStack.data[++seqStack.top] = data;  
14.          }  
15.          #endregion  

 

3：出栈

      同样跟“入栈”类似，需要做两件事情，①干掉top处的元素，②top指针自减。

代码段

[csharp]  view plain  copy

1. #region 出栈  
2.          /// <summary>  
3.  /// 出栈  
4.  /// </summary>  
5.  /// <typeparam name="T"></typeparam>  
6.  /// <param name="seqStack"></param>  
7.  /// <returns></returns>  
8.          public T SeqStackPop<T>(SeqStack<T> seqStack)  
9.          {  
10.              if (SeqStackIsEmpty(seqStack))  
11.                  throw new Exception("呜呜，栈已空");  
12.    
13.              seqStack.data[seqStack.top] = default(T);  
14.    
15.              return seqStack.data[--seqStack.top];  
16.          }  
17.          #endregion  

 

4：获取栈顶元素

      这个很简单，跟“出栈”唯一不同的是不破坏栈顶元素，只是翻出来看看而已。

 

代码段

[csharp]  view plain  copy

1. #region 获取栈顶  
2.          /// <summary>  
3.  /// 获取栈顶  
4.  /// </summary>  
5.  /// <typeparam name="T"></typeparam>  
6.  /// <param name="seqStack"></param>  
7.  /// <returns></returns>  
8.          public T SeqStackPeek<T>(SeqStack<T> seqStack)  
9.          {  
10.              if (SeqStackIsEmpty(seqStack))  
11.                  throw new Exception("栈已空");  
12.    
13.              return seqStack.data[seqStack.top];  
14.          }  
15.          #endregion  

 

总的运行代码如下

[csharp]  view plain  copy

1. View Code   
2.  using System;  
3.  using System.Collections.Generic;  
4.  using System.Linq;  
5.  using System.Text;  
6.    
7.  namespace SeqStack  
8.  {  
9.      class Program  
10.      {  
11.          static void Main(string[] args)  
12.          {  
13.              SeqStackClass stackManager = new SeqStackClass();  
14.    
15.              SeqStack<Student> seqStack = stackManager.SeqStackInit<Student>(10);  
16.    
17.              Console.WriteLine("********************  压入ID=1,ID=2,ID=3的元素  ***********************\n");  
18.              //压入ID=1,ID=2,ID=3的元素  
19.              stackManager.SeqStackPush(seqStack, new Student() { ID = 1, Name = "一线码农", Age = 23 });  
20.              stackManager.SeqStackPush(seqStack, new Student() { ID = 2, Name = "huangxincheng520", Age = 23 });  
21.              stackManager.SeqStackPush(seqStack, new Student() { ID = 3, Name = "51cto", Age = 23 });  
22.    
23.              Console.WriteLine(".... 压入成功，当前栈中元素有：" + stackManager.SeqStackLen(seqStack) + "个");  
24.    
25.              Console.WriteLine("\n******************  查看栈顶元素  ********************");  
26.    
27.              var result = stackManager.SeqStackPeek(seqStack);  
28.    
29.              Console.WriteLine("栈顶元素为：ID=" + result.ID + ",Name=" + result.Name + ",Age=" + result.Age);  
30.    
31.              Console.WriteLine("\n********************  弹出栈顶元素  ***********************");  
32.    
33.              stackManager.SeqStackPop(seqStack);  
34.    
35.              Console.WriteLine("\n******************  查看栈中的元素  ********************");  
36.    
37.              for (int i = 0; i < stackManager.SeqStackLen(seqStack); i++)  
38.              {  
39.                  Console.WriteLine("栈顶元素为：ID=" + seqStack.data[i].ID + ",Name=" + seqStack.data[i].Name + ",Age=" + seqStack.data[i].Age);  
40.              }  
41.    
42.              Console.Read();  
43.          }  
44.      }  
45.   
46.      #region 学生数据实体  
47.      /// <summary>  
48.  /// 学生数据实体  
49.  /// </summary>  
50.      public class Student  
51.      {  
52.          public int ID { get; set; }  
53.    
54.          public string Name { get; set; }  
55.    
56.          public int Age { get; set; }  
57.      }  
58.      #endregion  
59.   
60.      #region 栈的数据结构  
61.      /// <summary>  
62.  /// 栈的数据结构  
63.  /// </summary>  
64.      public class SeqStack<T>  
65.      {  
66.          public T[] data;  
67.    
68.          /// <summary>  
69.  /// 栈顶指针  
70.  /// </summary>  
71.          public int top = -1;  
72.    
73.          public SeqStack(int lenth)  
74.          {  
75.              data = new T[lenth];  
76.          }  
77.      }  
78.      #endregion  
79.    
80.      public class SeqStackClass  
81.      {  
82.          #region 栈的初始化操作  
83.          /// <summary>  
84.  /// 栈的初始化操作  
85.  /// </summary>  
86.  /// <typeparam name="T"></typeparam>  
87.  /// <returns></returns>  
88.          public SeqStack<T> SeqStackInit<T>(int length)  
89.          {  
90.              SeqStack<T> seqStack = new SeqStack<T>(length);  
91.    
92.              seqStack.top = -1;  
93.    
94.              return seqStack;  
95.          }  
96.          #endregion  
97.   
98.          #region 判断栈是否为空  
99.          /// <summary>  
100.  /// 判断栈是否为空  
101.  /// </summary>  
102.  /// <typeparam name="T"></typeparam>  
103.  /// <param name="seqStack"></param>  
104.  /// <returns></returns>  
105.          public bool SeqStackIsEmpty<T>(SeqStack<T> seqStack)  
106.          {  
107.              return seqStack.top == -1;  
108.          }  
109.          #endregion  
110.   
111.          #region 清空栈  
112.          /// <summary>  
113.  /// 清空栈  
114.  /// </summary>  
115.  /// <typeparam name="T"></typeparam>  
116.  /// <param name="seqStack"></param>  
117.          public void SeqStackClear<T>(SeqStack<T> seqStack)  
118.          {  
119.              seqStack.top = -1;  
120.          }  
121.          #endregion  
122.   
123.          #region 栈是否已满  
124.          /// <summary>  
125.  /// 栈是否已满  
126.  /// </summary>  
127.  /// <typeparam name="T"></typeparam>  
128.  /// <param name="seqStack"></param>  
129.          public bool SeqStackIsFull<T>(SeqStack<T> seqStack)  
130.          {  
131.              return seqStack.top == seqStack.data.Length;  
132.          }  
133.          #endregion  
134.   
135.          #region 入栈  
136.          /// <summary>  
137.  /// 入栈  
138.  /// </summary>  
139.  /// <typeparam name="T"></typeparam>  
140.  /// <param name="seqStack"></param>  
141.  /// <param name="data"></param>  
142.          public void SeqStackPush<T>(SeqStack<T> seqStack, T data)  
143.          {  
144.              if (SeqStackIsFull(seqStack))  
145.                  throw new Exception("不好意思，栈溢出");  
146.    
147.              seqStack.data[++seqStack.top] = data;  
148.          }  
149.          #endregion  
150.   
151.          #region 出栈  
152.          /// <summary>  
153.  /// 出栈  
154.  /// </summary>  
155.  /// <typeparam name="T"></typeparam>  
156.  /// <param name="seqStack"></param>  
157.  /// <returns></returns>  
158.          public T SeqStackPop<T>(SeqStack<T> seqStack)  
159.          {  
160.              if (SeqStackIsEmpty(seqStack))  
161.                  throw new Exception("呜呜，栈已空");  
162.    
163.              seqStack.data[seqStack.top] = default(T);  
164.    
165.              return seqStack.data[--seqStack.top];  
166.          }  
167.          #endregion  
168.   
169.          #region 获取栈顶  
170.          /// <summary>  
171.  /// 获取栈顶  
172.  /// </summary>  
173.  /// <typeparam name="T"></typeparam>  
174.  /// <param name="seqStack"></param>  
175.  /// <returns></returns>  
176.          public T SeqStackPeek<T>(SeqStack<T> seqStack)  
177.          {  
178.              if (SeqStackIsEmpty(seqStack))  
179.                  throw new Exception("栈已空");  
180.    
181.              return seqStack.data[seqStack.top];  
182.          }  
183.          #endregion  
184.   
185.          #region 获取栈中元素个数  
186.          /// <summary>  
187.  /// 获取栈中元素个数  
188.  /// </summary>  
189.  /// <typeparam name="T"></typeparam>  
190.  /// <param name="seqStack"></param>  
191.  /// <returns></returns>  
192.          public int SeqStackLen<T>(SeqStack<T> seqStack)  
193.          {  
194.              return seqStack.top + 1;  
195.          }  
196.          #endregion  
197.      }  
198.  }