常见的基本数据结构——栈
栈ADT
栈(stack)是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫做栈顶。栈的基本操作有进栈(push)和出栈(pop)，前者相当于插入，后者相当于删除最后的元素。在最后插入的元素可以通过使用Top例程在执行Pop之前进行考查。对空栈进行的Pop或Top一般被认为是栈ADT的错误。另一方面，当运行Push时空间用尽是一种实现错误，但不是ADT的错误。
栈有时又叫做LIFO(后进先出表)。
栈的实现
由于栈是一个表，因此任何实现表的方法都能够实现栈。两种流行的方法：一种是使用指针实现，一种是使用数组实现。
栈的链表实现
在表的顶端插入实现Push，在表的顶端删除实现Pop，Top只是返回顶端元素，有时Top和Pop两个也可以合二为一。
栈ADT链表的声明实现
struct Node； typedef struct Node *PtrTONode; typedef PtrToNode Stack; struct Node{ ElementType Node; PtrToNode Next; };
测试栈是否为空
int IsEmpty(Stack S){ return S->Next == NULL; }
创建一个空栈也很简单，我们只要建立一个头结点，MakeEmpty设置Next指针指向NULL。Push是作为向链表前端进行插入而实现的，其中，表的前端作为栈顶。Top的实现是返回表的前端的元素，Pop是通过删除表的前端元素实现。
创建一个空栈的过程
Stack CreateStack(void){ Stack S; S = malloc(sizeof(struct Node)); if(S == NULL){ printf(” out of space”); } S->Next == NULL; MakeEmpty(S); return S; }
void MakeEmpty(Stack S){ if(S == NULL){ Error(); }else{ while(!IsEmpty(S)){ Pop(s); } }
Push进栈例程
void Push(ElememtType X, Stack S){ PtrToNode TemCell; TemCell = malloc(sizeof(struct Node)); if(TemCell == NULL){ Error(); }else{ TemCell->ElementType = X; TemCell->Next = S->Next; S->Next = TemCell; } }
Pop操作实现
ElementType Top(Stack S){ if(!IsEmpty(S)) return S->Next->Element; Error(); return 0; }
对于链表的实现，所有的操作基本上都只花费常数的时间，上述的操作出了空栈之外都没有涉及到栈的大小，更没有依赖栈进行循环了。这种实现的缺点是对于malloc和free操作是昂贵的开销。有的缺点可以通过两个栈进行避免，第二个栈初始化为空栈，当单元弹出时，它只是被放入到第二个栈，此后当需要新空间时，首先检查第二个空栈。
栈的数组实现
数组实现避免了指针操作并且是更流行的实现，唯一的不足是它先要声明一个数组的大小。通常栈的实际个数并不会太大，声明一个合理的空间没有什么困难。如果不能的话，那就采用链表实现。数组实现栈是非常简单的，每一个栈都有一个TopOfStack，空栈时为-1，当某个元素压入栈时，将TopOfStack加1，然后至Stack[TopOfStack] = X;其中，Stack就是具体栈的数组。出栈时，我们返回Stack[TopOfStack]的值，然后TopOfStack减1，为了Stack和TopOfStack相对应，它们应该是栈结构的一部分。
上述的操作不仅以常数时间运行，而且是以非常快的时间运行。在现代化的计算机中，栈已经成为操作系统指令的一部分。一个影响栈执行效率的问题是错误检查。
栈的声明
struct StackRecord； tepedef struct StructRecord * Stack; struct StackRecord{ int Capacity; int TopOfStack; int ElementType *Array; }
Stack CreateStack(int MaxElement){ Stack S; if(MaxElement < MinStackSize) Error(); S = malloc(sizeof(struct StackRecord)); if(S == NULL) Error(); S->Array = malloc(sizeof(ElementType) * MaxElement); if(S->Array == NULL) Error(); S->Capacity = MaxElements; MakeEmpty(S); return S; }
检测栈是否为空
int IsEmpty(Stack S){ return S->TopOfStack == EmptyTOS; }
创建一个空栈
void MakeEmpty(Stack S){ S->TopOfStack = EmptyTOS; }
进栈操作
void Push(ElementType S, Stack S){ if(IsFull(S)) Error(); else S->Array[++S->TopOfStack] = X; }
返回栈顶元素
ElementType Top(Stack S){ if(!IsEmpty(S)) return S->Array[S->TopOfStack]; Error(); return 0; }
从栈顶弹出元素
void Pop(Stack S){ if(IsEmpty) Error(); else S-TopOfStack—; }
将Top和Pop进行合并
ElementType TopAndPop(Stack S){ if(!IsEmpty(S)){ return S->Array[S->TopOfStack]; } Error(); return 0; }
应用
平衡符号
编译器检查你的程序的语法错误，当时常常由于缺少一个符号造成上百行的错误。在这种情况下，就需要一个工具检验成对出现，每一个双符号都要有对应的符号，一个简单的算法就用到栈，如下描述：
做一个空栈。读入字符直到文件尾。如果字符是一个开放字符，则将其推入栈中，如果字符是一个封闭符号，则当栈空时报错。否则，将栈元素弹出，如果弹出的符号不是对应的开放符号，则报错。在文件尾，如果栈非空则报错。
上述的算法是线性的，事实上，它只要对输入进行一趟检验。因此，它是在线的，速度非常的快。
后缀表达式
在一个由优先级构成的算术表达式中，我们通常要根据运算符的有限级进行计算结果。请下面的例子：
4.99 + 5.99 + 6.99 * 1.06 = 18.69
如果没有考虑优先级的话，计算的结果将是19.37.我们可以通过下面的方法进行计算，操作顺序如下：
4.99 1.06 * 5.99 +6.99 1.06 * +
上面的记发叫做后缀或者逆波兰记法。计算这个问题最容易的办法就是使用一个栈：当遇见数时，就把它放入栈中，在遇到运算符时就作用于栈中弹出的两个数，并将结果推入栈中。
计算一个后缀表达式的时间是线性的O(N)，对输入的元素由一些栈操作组成从未花费常数的时间，并且不必要知道任何的有限顺序。
中缀到后缀的转换
栈不仅可以计算后缀表达式，而且还可以将一个标准的表达式(中缀表达式)转换成后缀表达式。如下中缀表达式：
a + b * c + (d * e + f) * g
转换成后缀表达式：
a b c * + d e * f + g * +
具体操作是：当读到一个操作数的时候，立即把它放到输出中，操作符不立即输出，保存在某个地方，正确的做法是将遇到的操作符保存在栈中，遇到左括号也放入栈中。
如果遇见一个右括号，那么就将栈元素弹出，将弹出的符号输出直到遇见相匹配的左括号，但是左括号不进行输出。
如果我们遇见任何其他的符号，那么我们从栈中弹出栈元素直到发现优先级更低的元素为止。有一个例外，除非是一个）的时候，否则我们绝不从栈中移除（。对于这种操作，+的优先级最低，（优先级最高。当弹出元素结束后，我们在将操作符移入栈中。
当到达末尾时，我们将栈中元素弹出，变成空栈，将符号输出。
同样，这种转换只需要O（N）的，对于运算符时是从左到右的结合的，上面的算法是正确的，不然就需要重新设计。
函数调用
当存在函数调用时，需要存储重要的信息，诸如寄存器的值，和返回的地址，都要以抽象的方式存在一张纸上并被置于一个堆的顶部。
递归的不当使用:打印一个链表
void PrintList(List L){ if(L != NULL){ PrintElement(L->Element); PrintList(L->Next); } }
这个程序是尾递归，是使用极端不当的例子，尾部涉及在最后一步的递归。
尾递归可以通过将递归调用变成goto语句并在其前加上对函数每个参数的赋值语句而手工删除。它模拟了递归调用，因为没有什么需要存储的值，在递归调用之后，实际上没有必要知道存储的值。下面是通过goto改造的while循环实现：
void PrintList(List L){ top: if(L != NULL){ PrintElement(L->Element); L = L->Next; goto top; } }
递归总是能够彻底除去，但是有时是相当冗长复杂的。一般方法是使用一个栈来消除，虽然非递归确实比递归程序要快，但是速度的优势代价确实由于去除而使得程序的清晰度不足。
