# 第十天 栈

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

``` 1 #region 栈的数据结构
/// <summary>
/// 栈的数据结构
/// </summary>
public class SeqStack<T>
{
public T[] data;

/// <summary>
/// 栈顶指针
/// </summary>
public int top = -1;

public SeqStack(int lenth)
{
data = new T[lenth];
}
}
#endregion```

1: 初始化栈

``` 1 #region 栈的初始化操作
/// <summary>
/// 栈的初始化操作
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public SeqStack<T> SeqStackInit<T>(int length)
{
SeqStack<T> seqStack = new SeqStack<T>(length);

seqStack.top = -1;

return seqStack;
}
#endregion```

2：入栈

``` 1 #region 入栈
/// <summary>
/// 入栈
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="seqStack"></param>
/// <param name="data"></param>
public void SeqStackPush<T>(SeqStack<T> seqStack, T data)
{
if (SeqStackIsFull(seqStack))
throw new Exception("不好意思，栈溢出");

seqStack.data[++seqStack.top] = data;
}
#endregion```

3：出栈

``` 1 #region 出栈
/// <summary>
/// 出栈
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="seqStack"></param>
/// <returns></returns>
public T SeqStackPop<T>(SeqStack<T> seqStack)
{
if (SeqStackIsEmpty(seqStack))
throw new Exception("呜呜，栈已空");

seqStack.data[seqStack.top] = default(T);

return seqStack.data[--seqStack.top];
}
#endregion```

4：获取栈顶元素

``` 1 #region 获取栈顶
/// <summary>
/// 获取栈顶
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="seqStack"></param>
/// <returns></returns>
public T SeqStackPeek<T>(SeqStack<T> seqStack)
{
if (SeqStackIsEmpty(seqStack))
throw new Exception("栈已空");

return seqStack.data[seqStack.top];
}
#endregion```

View Code

```  1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5
6 namespace SeqStack
7 {
8     class Program
9     {
static void Main(string[] args)
{
SeqStackClass stackManager = new SeqStackClass();

SeqStack<Student> seqStack = stackManager.SeqStackInit<Student>(10);

Console.WriteLine("********************  压入ID=1,ID=2,ID=3的元素  ***********************\n");
//压入ID=1,ID=2,ID=3的元素
stackManager.SeqStackPush(seqStack, new Student() { ID = 1, Name = "一线码农", Age = 23 });
stackManager.SeqStackPush(seqStack, new Student() { ID = 2, Name = "huangxincheng520", Age = 23 });
stackManager.SeqStackPush(seqStack, new Student() { ID = 3, Name = "51cto", Age = 23 });

Console.WriteLine(".... 压入成功，当前栈中元素有：" + stackManager.SeqStackLen(seqStack) + "个");

Console.WriteLine("\n******************  查看栈顶元素  ********************");

var result = stackManager.SeqStackPeek(seqStack);

Console.WriteLine("栈顶元素为：ID=" + result.ID + ",Name=" + result.Name + ",Age=" + result.Age);

Console.WriteLine("\n********************  弹出栈顶元素  ***********************");

stackManager.SeqStackPop(seqStack);

Console.WriteLine("\n******************  查看栈中的元素  ********************");

for (int i = 0; i < stackManager.SeqStackLen(seqStack); i++)
{
Console.WriteLine("栈顶元素为：ID=" + seqStack.data[i].ID + ",Name=" + seqStack.data[i].Name + ",Age=" + seqStack.data[i].Age);
}

}
}

#region 学生数据实体
/// <summary>
/// 学生数据实体
/// </summary>
public class Student
{
public int ID { get; set; }

public string Name { get; set; }

public int Age { get; set; }
}
#endregion

#region 栈的数据结构
/// <summary>
/// 栈的数据结构
/// </summary>
public class SeqStack<T>
{
public T[] data;

/// <summary>
/// 栈顶指针
/// </summary>
public int top = -1;

public SeqStack(int lenth)
{
data = new T[lenth];
}
}
#endregion

public class SeqStackClass
{
#region 栈的初始化操作
/// <summary>
/// 栈的初始化操作
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public SeqStack<T> SeqStackInit<T>(int length)
{
SeqStack<T> seqStack = new SeqStack<T>(length);

seqStack.top = -1;

return seqStack;
}
#endregion

#region 判断栈是否为空
/// <summary>
/// 判断栈是否为空
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="seqStack"></param>
/// <returns></returns>
public bool SeqStackIsEmpty<T>(SeqStack<T> seqStack)
{
return seqStack.top == -1;
}
#endregion

#region 清空栈
/// <summary>
/// 清空栈
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="seqStack"></param>
public void SeqStackClear<T>(SeqStack<T> seqStack)
{
seqStack.top = -1;
}
#endregion

#region 栈是否已满
/// <summary>
/// 栈是否已满
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="seqStack"></param>
public bool SeqStackIsFull<T>(SeqStack<T> seqStack)
{
return seqStack.top == seqStack.data.Length;
}
#endregion

#region 入栈
/// <summary>
/// 入栈
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="seqStack"></param>
/// <param name="data"></param>
public void SeqStackPush<T>(SeqStack<T> seqStack, T data)
{
if (SeqStackIsFull(seqStack))
throw new Exception("不好意思，栈溢出");

seqStack.data[++seqStack.top] = data;
}
#endregion

#region 出栈
/// <summary>
/// 出栈
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="seqStack"></param>
/// <returns></returns>
public T SeqStackPop<T>(SeqStack<T> seqStack)
{
if (SeqStackIsEmpty(seqStack))
throw new Exception("呜呜，栈已空");

seqStack.data[seqStack.top] = default(T);

return seqStack.data[--seqStack.top];
}
#endregion

#region 获取栈顶
/// <summary>
/// 获取栈顶
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="seqStack"></param>
/// <returns></returns>
public T SeqStackPeek<T>(SeqStack<T> seqStack)
{
if (SeqStackIsEmpty(seqStack))
throw new Exception("栈已空");

return seqStack.data[seqStack.top];
}
#endregion

#region 获取栈中元素个数
/// <summary>
/// 获取栈中元素个数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="seqStack"></param>
/// <returns></returns>
public int SeqStackLen<T>(SeqStack<T> seqStack)
{
return seqStack.top + 1;
}
#endregion
}
}```