[转]stack(顺序、链式及应用)

（java版）

1. 顺序栈的实现

 顺序栈实现1
[java] 
 
  1. package lang;  
  2.   
  3. import java.io.Serializable;  
  4. import java.util.Arrays;  
  5.   
  6. /**  
  7.  * @ClassName: ArrayStack 
  8.  * @Description: 顺序栈 
  9.  * @date 2014年1月20日 上午8:47:19 
  10.  * @param <T> 
  11.  */  
  12. public class ArrayStack<T> implements Serializable {  
  13.   
  14.   /** 
  15.    * @Fields serialVersionUID : TODO 
  16.    */  
  17.   private static final long serialVersionUID = 74027006708386243L;  
  18.   
  19.   private Object[] elementData;//定义一个数组用于保存顺序栈的元素  
  20.   
  21.   private int size = 0;//保存顺序栈中元素的当前个数  
  22.   
  23.   private int capacity;//保存数组的长度  
  24.   
  25.   public ArrayStack() {  
  26.     elementData = new Object[10];//默认长度为10的栈      
  27.   }  
  28.   
  29.   public ArrayStack(int initSize) {  
  30.     elementData = new Object[initSize];//默认长度为10的栈  
  31.   }  
  32.   
  33.   public ArrayStack(T element) {  
  34.     this();  
  35.     elementData[0] = element;  
  36.     size++;  
  37.   }  
  38.   
  39.   public ArrayStack(T element, int initSize) {  
  40.     this.capacity = initSize;  
  41.     elementData = new Object[capacity];  
  42.     elementData[0] = element;  
  43.     size++;  
  44.   }  
  45.   
  46.   /** 
  47.    * @Title: size      
  48.    * @Description: 栈长度     
  49.    * @return 
  50.    */  
  51.   public int size() {  
  52.     return size;  
  53.   }  
  54.   
  55.   /** 
  56.    * @Title: push      
  57.    * @Description: 入栈     
  58.    * @param element 
  59.    */  
  60.   public void push(T element) {  
  61.     ensureCapacity(size + 1);  
  62.     elementData[size++] = element;  
  63.   }  
  64.   
  65.   private void ensureCapacity(int minCapacity) {  
  66.     //如果数组的原有长度小于目前所需的长度  
  67.     int oldCapacity = elementData.length;  
  68.     if (minCapacity > oldCapacity) {  
  69.       int newCapacity = (oldCapacity * 3) / 2 + 1;  
  70.       if (newCapacity < minCapacity)  
  71.         newCapacity = minCapacity;  
  72.       // minCapacity is usually close to size, so this is a win:  
  73.       elementData = Arrays.copyOf(elementData, newCapacity);  
  74.     }  
  75.   
  76.   }  
  77.   
  78.   /** 
  79.    * @Title: pop      
  80.    * @Description: 出栈     
  81.    * @return 
  82.    */  
  83.   public T pop() {  
  84.     if (!isEmpty()) {  
  85.       T oldValue = (T) elementData[size - 1];  
  86.       //释放栈顶元素  
  87.       elementData[--size] = null;  
  88.       return oldValue;  
  89.     } else {  
  90.       return null;  
  91.     }  
  92.   }  
  93.   
  94.   /** 
  95.    * @Title: peek      
  96.    * @Description: 返回栈顶元素，但不删除栈顶元素     
  97.    * @return 
  98.    */  
  99.   public T peek() {  
  100.     if (!isEmpty()) {  
  101.       return (T) elementData[size - 1];  
  102.     } else {  
  103.       throw new IndexOutOfBoundsException("空栈异常");  
  104.     }  
  105.   }  
  106.   
  107.   /** 
  108.    * @Title: empty      
  109.    * @Description: 判断顺序栈是否为空栈     
  110.    * @return 
  111.    */  
  112.   public boolean isEmpty() {  
  113.     return size == 0;  
  114.   }  
  115.   
  116.   /** 
  117.    * @Title: clear      
  118.    * @Description: 清空顺序栈 
  119.    */  
  120.   public void clear() {  
  121.     //将底层数组所有元素赋为null  
  122.     Arrays.fill(elementData, null);  
  123.     size = 0;  
  124.   }  
  125.   
  126.   public String toString() {  
  127.     if (size == 0) {  
  128.       return "[]";  
  129.     } else {  
  130.       StringBuilder sb = new StringBuilder("[");  
  131.       for (int i = size - 1; i > -1; i--) {  
  132.         sb.append(elementData[i].toString() + ", ");  
  133.       }  
  134.       int len = sb.length();  
  135.       return sb.delete(len - 2, len).append("]").toString();  
  136.     }  
  137.   }  
  138. }  

 顺序栈实现2

[java]
 
  1. package lang;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.EmptyStackException;  
  5.   
  6. public class ArrayStack2<E> extends ArrayList<E> {  
  7.   
  8.   /** 
  9.    * @Fields serialVersionUID : TODO 
  10.    */  
  11.   private static final long serialVersionUID = -4396620094929287983L;  
  12.   
  13.   public ArrayStack2() {  
  14.     super();  
  15.   }  
  16.   
  17.   public ArrayStack2(final int initialSize) {  
  18.     super(initialSize);  
  19.   }  
  20.   
  21.   public boolean empty() {  
  22.     return isEmpty();  
  23.   }  
  24.   
  25.   public E peek() throws EmptyStackException {  
  26.     final int n = size();  
  27.     if (n <= 0) {  
  28.       throw new EmptyStackException();  
  29.     } else {  
  30.       return get(n - 1);  
  31.     }  
  32.   }  
  33.   
  34.   public E peek(final int n) throws EmptyStackException {  
  35.     final int m = (size() - n) - 1;  
  36.     if (m < 0) {  
  37.       throw new EmptyStackException();  
  38.     } else {  
  39.       return get(m);  
  40.     }  
  41.   }  
  42.   
  43.   public E pop() throws EmptyStackException {  
  44.     final int n = size();  
  45.     if (n <= 0) {  
  46.       throw new EmptyStackException();  
  47.     } else {  
  48.       return remove(n - 1);  
  49.     }  
  50.   }  
  51.   
  52.   public E push(final E item) {  
  53.     add(item);  
  54.     return item;  
  55.   }  
  56.   
  57.   public int search(final Object object) {  
  58.     int i = size() - 1; // Current index  
  59.     int n = 1; // Current distance  
  60.     while (i >= 0) {  
  61.       final Object current = get(i);  
  62.       if ((object == null && current == null)  
  63.         || (object != null && object.equals(current))) {  
  64.         return n;  
  65.       }  
  66.       i--;  
  67.       n++;  
  68.     }  
  69.     return -1;  
  70.   }  
  71. }  



2. 链式栈的实现：

[java] 
 
  1. package lang;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. /** 
  6.  * @ClassName: LinkStack 
  7.  * @Description: 链式栈 
  8.  * @date 2014年1月20日 下午3:46:40 
  9.  * @param <T> 
  10.  */  
  11. public class LinkStack<T> implements Serializable{  
  12.   /** 
  13.    * @Fields serialVersionUID : TODO 
  14.    */  
  15.   private static final long serialVersionUID = -4378447264374701299L;  
  16.   
  17.   private class Node{  
  18.     private T data; //保存节点的数据   
  19.       
  20.     private Node next; //指向下个节点的引用  
  21.       
  22.     public Node(){  
  23.         
  24.     }  
  25.       
  26.     public Node(T data, Node next){  
  27.       this.data = data;  
  28.       this.next = next;  
  29.     }  
  30.   }  
  31.     
  32.   private Node top;  //保存该链栈的栈顶元素     
  33.    
  34.   private int size = 0;   //保存该链栈中已包含的节点数,即栈的长度  
  35.   
  36.   public LinkStack(){  
  37.     top = null;  
  38.   }  
  39.     
  40.   public LinkStack(T element) {  
  41.     top = new Node(element , null);     
  42.     size++;   
  43.   }  
  44.     
  45.   /** 
  46.    * @Title: size      
  47.    * @Description: 栈的长度     
  48.    * @return 
  49.    */  
  50.   public int size(){  
  51.     return size;  
  52.   }  
  53.     
  54.   /** 
  55.    * @Title: push      
  56.    * @Description: 入栈     
  57.    * @param element 
  58.    */  
  59.   public void push(T element){  
  60.     top = new Node(element , top);     
  61.     size++;  
  62.   }  
  63.     
  64.   /** 
  65.    * @Title: pop      
  66.    * @Description: 出栈     
  67.    * @return 
  68.    */  
  69.   public T pop(){  
  70.     Node oldTop = top;  
  71.     top = top.next;  
  72.     oldTop.next = null;  
  73.     size--;  
  74.     return oldTop.data;  
  75.   }  
  76.     
  77.   /** 
  78.    * @Title: peek      
  79.    * @Description: 访问栈顶元素     
  80.    * @return 
  81.    */  
  82.   public T peek(){  
  83.     return top.data;  
  84.   }  
  85.     
  86.   /** 
  87.    * @Title: empty      
  88.    * @Description: 判断顺序栈是否为空栈     
  89.    * @return 
  90.    */  
  91.   public boolean isEmpty() {  
  92.     return size == 0;  
  93.   }  
  94.   
  95.   /** 
  96.    * @Title: clear      
  97.    * @Description: 清空顺序栈 
  98.    */  
  99.   public void clear() {     
  100.     top = null;//将栈所有元素赋为null  
  101.     size = 0;  
  102.   }  
  103.   
  104.   public String toString() {     
  105.         //链栈为空链栈时     
  106.     if (isEmpty()) {     
  107.       return "[]";     
  108.     } else {     
  109.       StringBuilder sb = new StringBuilder("[");     
  110.       for (Node current = top ; current != null ; current = current.next ) {     
  111.         sb.append(current.data.toString() + ", ");     
  112.       }     
  113.       int len = sb.length();     
  114.       return sb.delete(len - 2 , len).append("]").toString();     
  115.     }     
  116.   }     
  117.   
  118. }  

3. 栈的应用

3.1 将10进制正整数num转换为n进制

[java]
 
  1. package stack.apply;  
  2.   
  3. import org.junit.Test;  
  4.   
  5. import lang.ArrayStack;  
  6.   
  7. /** 
  8.  * @ClassName: Conversion 
  9.  * @Description: 将10进制正整数num转换为n进制 
  10.  * @date 2014年1月21日 上午9:47:22 
  11.  */  
  12. public class Conversion {  
  13.     
  14.   /** 
  15.    * @Title: conversion      
  16.    * @Description: 将10进制正整数num转换为n进制     
  17.    * @param num: 10进制正整数 
  18.    * @param n: n进制 
  19.    * @return 转换后的值 
  20.    */  
  21.   private String conversion(int num, int n) {  
  22.     ArrayStack<Integer> myStack = new ArrayStack<Integer>();  
  23.     Integer result = num;  
  24.     while (true) {  
  25.       // 将余数入栈  
  26.       myStack.push(result % n);  
  27.       result = result / n;  
  28.       if (result == 0) {  
  29.         break;  
  30.       }  
  31.     }  
  32.     StringBuilder sb = new StringBuilder();  
  33.     // 按出栈的顺序倒序排列即可  
  34.     while ((result = myStack.pop()) != null) {  
  35.       sb.append(result);  
  36.     }  
  37.     return sb.toString();  
  38.   }  
  39.     
  40.   @Test  
  41.   public void testConversion(){  
  42.     String s = conversion(13,2);  
  43.     System.out.println(s);  
  44.   }  
  45. }  


3.2 行编辑:

输入行中字符'#'表示退格, '@'表示之前的输入全都无效.

[java] 
 
  1. package stack.apply;  
  2.   
  3. import org.junit.Test;  
  4.   
  5. import lang.ArrayStack;  
  6.   
  7. /** 
  8.  * @ClassName: LineEdit 
  9.  * @Description: 行编辑: 输入行中字符'#'表示退格, '@'表示之前的输入全都无效. 
  10.  * @date 2014年1月21日 上午10:17:06 
  11.  */  
  12. public class LineEdit {  
  13.   /** 
  14.    * @Title: lineEdit      
  15.    * @Description: 行编辑     
  16.    * @param input 
  17.    * @return 
  18.    */  
  19.   private String lineEdit(String input) {  
  20.     ArrayStack<Character> myStack = new ArrayStack<Character>();  
  21.     char[] arr = input.toCharArray();  
  22.     for (char c : arr) {  
  23.       if (c == '#') {  
  24.         myStack.pop();  
  25.       } else if (c == '@') {  
  26.         myStack.clear();  
  27.       } else {  
  28.         myStack.push(c);  
  29.       }  
  30.     }  
  31.       
  32.     StringBuilder sb = new StringBuilder();  
  33.     Character temp = null;  
  34.     while ((temp = myStack.pop()) != null) {  
  35.       sb.append(temp);  
  36.     }  
  37.     // 反转字符串  
  38.     sb.reverse();  
  39.     return sb.toString();  
  40.   }  
  41.     
  42.   @Test  
  43.   public void testLineEdit(){  
  44.     String s = lineEdit("abcd#dsa@#usera#22#8");  
  45.     System.out.println(s);  
  46.   }  
  47. }  


3.3 检验符号是否匹配.

 '['和']', '('和')'成对出现时字符串合法. 
   例如"[][]()", "[[([]([])()[])]]"是合法的; "([(])", "[())"是不合法的

[java] 
 
    1. package stack.apply;  
    2.   
    3. import org.junit.Test;  
    4.   
    5. import lang.ArrayStack;  
    6.   
    7. /** 
    8.  * @ClassName: Match 
    9.  * @Description: 检验符号是否匹配. '['和']', '('和')'成对出现时字符串合法.  
    10.  * 例如"[][]()", "[[([]([])()[])]]"是合法的; "([(])", "[())"是不合法的 
    11.  * @date 2014年1月21日 上午10:14:47 
    12.  */  
    13. public class Match {  
    14.   /** 
    15.    * @Title: isMatch      
    16.    * @Description: 检验符号是否匹配     
    17.    * @param str 输入要匹配的字符串 
    18.    * @return 是否匹配 
    19.    */  
    20.   public boolean isMatch(String str) {  
    21.     ArrayStack<Character> myStack = new ArrayStack<Character>();  
    22.     char[] arr = str.toCharArray();  
    23.     for (char c : arr) {  
    24.       Character temp = myStack.pop();  
    25.       // 栈为空时只将c入栈  
    26.       if (temp == null) {  
    27.         myStack.push(c);  
    28.       }  
    29.       // 配对时c不入栈  
    30.       else if (temp == '[' && c == ']') {  
    31.       }   
    32.       // 配对时c不入栈  
    33.       else if (temp == '(' && c == ')') {  
    34.       }   
    35.       // 不配对时c入栈  
    36.       else {  
    37.         myStack.push(temp);  
    38.         myStack.push(c);  
    39.       }  
    40.     }  
    41.     return myStack.isEmpty();  
    42.   }  
    43.     
    44.   @Test  
    45.   public void testMatch(){  
    46.     boolean b = isMatch("[[([]([])()[])]]");  
    47.     System.out.println(b);  
    48.   }  
    49. }
    52. ===================================
    53. (java)

    54. 栈的实现

      栈是一种先进后出的数据结构, 首先定义了栈需要实现的接口：

      1. public interface MyStack<T> {  
      2.     /**  
      3.      * 判断栈是否为空  
      4.      */ 
      5.     boolean isEmpty();  
      6.     /**  
      7.      * 清空栈  
      8.      */ 
      9.     void clear();  
      10.     /**  
      11.      * 栈的长度  
      12.      */ 
      13.     int length();  
      14.     /**  
      15.      * 数据入栈  
      16.      */ 
      17.     boolean push(T data);  
      18.     /**  
      19.      * 数据出栈  
      20.      */ 
      21.     T pop();  
      22. } 

      栈的数组实现，底层使用数组：

      1. public class MyArrayStack<T> implements MyStack<T> {  
      2.     private Object[] objs = new Object[16];  
      3.     private int size = 0;  
      4.  
      5.     @Override 
      6.     public boolean isEmpty() {  
      7.         return size == 0;  
      8.     }  
      9.  
      10.     @Override 
      11.     public void clear() {  
      12.         // 将数组中的数据置为null, 方便GC进行回收  
      13.         for (int i = 0; i < size; i++) {  
      14.             objs[size] = null;  
      15.         }  
      16.         size = 0;  
      17.     }  
      18.  
      19.     @Override 
      20.     public int length() {  
      21.         return size;  
      22.     }  
      23.  
      24.     @Override 
      25.     public boolean push(T data) {  
      26.         // 判断是否需要进行数组扩容  
      27.         if (size >= objs.length) {  
      28.             resize();  
      29.         }  
      30.         objs[size++] = data;  
      31.         return true;  
      32.     }  
      33.  
      34.     /**  
      35.      * 数组扩容  
      36.      */ 
      37.     private void resize() {  
      38.         Object[] temp = new Object[objs.length * 3 / 2 + 1];  
      39.         for (int i = 0; i < size; i++) {  
      40.             temp[i] = objs[i];  
      41.             objs[i] = null;  
      42.         }  
      43.         objs = temp;  
      44.     }  
      45.  
      46.     @SuppressWarnings("unchecked")  
      47.     @Override 
      48.     public T pop() {  
      49.         if (size == 0) {  
      50.             return null;  
      51.         }  
      52.         return (T) objs[--size];  
      53.     }  
      54.  
      55.     @Override 
      56.     public String toString() {  
      57.         StringBuilder sb = new StringBuilder();  
      58.         sb.append("MyArrayStack: [");  
      59.         for (int i = 0; i < size; i++) {  
      60.             sb.append(objs[i].toString());  
      61.             if (i != size - 1) {  
      62.                 sb.append(", ");  
      63.             }  
      64.         }  
      65.         sb.append("]");  
      66.         return sb.toString();  
      67.     }  
      68. }&nbsp;&nbsp; 

      栈的链表实现，底层使用链表：

      1. public class MyLinkedStack<T> implements MyStack<T> {  
      2.     /**  
      3.      * 栈顶指针  
      4.      */ 
      5.     private Node top;  
      6.     /**  
      7.      * 栈的长度  
      8.      */ 
      9.     private int size;  
      10.       
      11.     public MyLinkedStack() {  
      12.         top = null;  
      13.         size = 0;  
      14.     }  
      15.       
      16.     @Override 
      17.     public boolean isEmpty() {  
      18.         return size == 0;  
      19.     }  
      20.       
      21.     @Override 
      22.     public void clear() {  
      23.         top = null;  
      24.         size = 0;  
      25.     }  
      26.       
      27.     @Override 
      28.     public int length() {  
      29.         return size;  
      30.     }  
      31.       
      32.     @Override 
      33.     public boolean push(T data) {  
      34.         Node node = new Node();  
      35.         node.data = data;  
      36.         node.pre = top;  
      37.         // 改变栈顶指针  
      38.         top = node;  
      39.         size++;  
      40.         return true;  
      41.     }  
      42.       
      43.     @Override 
      44.     public T pop() {  
      45.         if (top != null) {  
      46.             Node node = top;  
      47.             // 改变栈顶指针  
      48.             top = top.pre;  
      49.             size--;  
      50.             return node.data;  
      51.         }  
      52.         return null;  
      53.     }  
      54.       
      55.     /**  
      56.      * 将数据封装成结点  
      57.      */ 
      58.     private final class Node {  
      59.         private Node pre;  
      60.         private T data;  
      61.     }  
      62. } 

      两种实现的比较，主要比较数据入栈和出栈的速度：

      1. @Test 
      2. public void testSpeed() {  
      3.     MyStack<Person> stack = new MyArrayStack<Person>();  
      4.     int num = 10000000;  
      5.     long start = System.currentTimeMillis();  
      6.     for (int i = 0; i < num; i++) {  
      7.         stack.push(new Person("xing", 25));  
      8.     }  
      9.     long temp = System.currentTimeMillis();  
      10.     System.out.println("push time: " + (temp - start));  
      11.     while (stack.pop() != null)  
      12.         ;  
      13.     System.out.println("pop time: " + (System.currentTimeMillis() - temp));  
      14. } 

      MyArrayStack中入栈和出栈10,000,000条数据的时间：

      push time：936

      pop time：47

      将MyArrayStack改为MyLinkedStack后入栈和出栈的时间：

      push time：936

      pop time：126

      可见两者的入栈速度差不多，出栈速度MyArrayStack则有明显的优势。

      为什么测试结果是这样的？可能有些朋友的想法是数组实现的栈应该具有更快的遍历速度，但增删速度应该比不上链表实现的栈才对。但是栈中数据的增删具有特殊性：只在栈顶入栈和出栈。也就是说数组实现的栈在增加和删除元素时并不需要移动大量的元素，只是在数组扩容时需要进行复制。而链表实现的栈入栈和出栈时都需要将数据包装成Node或者从Node中取出数据，还需要维护栈顶指针和前驱指针。

      栈的应用举例

      1. 将10进制正整数num转换为n进制

      1. private String conversion(int num, int n) {  
      2.     MyStack<Integer> myStack = new MyArrayStack<Integer>();  
      3.     Integer result = num;  
      4.     while (true) {  
      5.         // 将余数入栈  
      6.         myStack.push(result % n);  
      7.         result = result / n;  
      8.         if (result == 0) {  
      9.             break;  
      10.         }  
      11.     }  
      12.     StringBuilder sb = new StringBuilder();  
      13.     // 按出栈的顺序倒序排列即可  
      14.     while ((result = myStack.pop()) != null) {  
      15.         sb.append(result);  
      16.     }  
      17.     return sb.toString();  
      18. } 

      2. 检验符号是否匹配. '['和']', '('和')'成对出现时字符串合法. 例如"[][]()", "[[([]([])()[])]]"是合法的; "([(])", "[())"是不合法的。

      遍历字符串的每一个char, 将char与栈顶元素比较. 如果char和栈顶元素配对, 则char不入栈, 否则将char入栈. 当遍历完成时栈为空说明字符串是合法的。

      1. public boolean isMatch(String str) {  
      2.     MyStack<Character> myStack = new MyArrayStack<Character>();  
      3.     char[] arr = str.toCharArray();  
      4.     for (char c : arr) {  
      5.         Character temp = myStack.pop();  
      6.         // 栈为空时只将c入栈  
      7.         if (temp == null) {  
      8.             myStack.push(c);  
      9.         }  
      10.         // 配对时c不入栈  
      11.         else if (temp == '[' && c == ']') {  
      12.         }   
      13.         // 配对时c不入栈  
      14.         else if (temp == '(' && c == ')') {  
      15.         }   
      16.         // 不配对时c入栈  
      17.         else {  
      18.             myStack.push(temp);  
      19.             myStack.push(c);  
      20.         }  
      21.     }  
      22.     return myStack.isEmpty();  
      23. } 

      3. 行编辑: 输入行中字符'#'表示退格, '@'表示之前的输入全都无效。

      使用栈保存输入的字符, 如果遇到'#'就将栈顶出栈, 如果遇到@就清空栈. 输入完成时将栈中所有字符出栈后反转就是输入的结果：

      1. private String lineEdit(String input) {  
      2.     MyStack<Character> myStack = new MyArrayStack<Character>();  
      3.     char[] arr = input.toCharArray();  
      4.     for (char c : arr) {  
      5.         if (c == '#') {  
      6.             myStack.pop();  
      7.         } else if (c == '@') {  
      8.             myStack.clear();  
      9.         } else {  
      10.             myStack.push(c);  
      11.         }  
      12.     }  
      13.       
      14.     StringBuilder sb = new StringBuilder();  
      15.     Character temp = null;  
      16.     while ((temp = myStack.pop()) != null) {  
      17.         sb.append(temp);  
      18.     }  
      19.     // 反转字符串  
      20.     sb.reverse();  
      21.     return sb.toString();  
    59.  
    62. (c版)

    63. 判断一行字符串输入"各种括号"是否是合法的-----------------------栈用数组实现

      如：[()]是合法的(balance)

      [(])是不合法的(imbalance)

      [cpp] view plaincopy
       
      1. #include <stdio.h>  
      2. #include <stdlib.h>  
      3. #include <string.h>  
      4.   
      5. typedef struct Mystack *Stack;  
      6.   
      7. struct Mystack {  
      8.     int Capacity;       /* 栈的容量 */  
      9.     int Top_of_stack;   /* 栈顶下标 */  
      10.     char *Array;        /* 存放栈中元素的数组 */  
      11. };  
      12.   
      13. /* 栈的创建 */  
      14. Stack CreateStack(int Max)  
      15. {  
      16.     Stack S;  
      17.     S = malloc(sizeof(struct Mystack));  
      18.     if (S == NULL)  
      19.         printf("Create stack error! ");  
      20.   
      21.     S->Array = malloc(sizeof(char) * Max);  
      22.     if (S->Array == NULL)  
      23.         printf("Create stack error! ");  
      24.   
      25.     S->Capacity = Max;  
      26.     S->Top_of_stack = 0;  
      27.     return S;  
      28. }  
      29.   
      30. /* 释放栈 */  
      31. void DisposeStack(Stack S)  
      32. {  
      33.     if (S != NULL)  
      34.     {     
      35.         free(S->Array);  
      36.         free(S);  
      37.     }     
      38. }  
      39.   
      40. /* 判断一个栈是否是空栈 */  
      41. int IsEmpty(Stack S)  
      42. {  
      43.     return !S->Top_of_stack;  
      44. }  
      45.   
      46. /* 判断一个栈是否满栈 */  
      47. int IsFull(Stack S)  
      48. {  
      49.     if (S->Top_of_stack == S->Capacity - 1)  
      50.         return 1;  
      51.     else  
      52.         return 0;  
      53. }  
      54.   
      55.   
      56. /* 数据入栈 */  
      57. int Push(int x, Stack S)  
      58. {  
      59.     if (IsFull(S))  
      60.         printf("The Stack is full! ");  
      61.     else  
      62.         S->Array[S->Top_of_stack++] = x;  
      63. }  
      64.   
      65. /* 数据出栈 */  
      66. int Pop(Stack S)  
      67. {  
      68.     if (IsEmpty(S))  
      69.         printf("The Stack is empty! ");  
      70.     else  
      71.         S->Top_of_stack--;  
      72. }  
      73.   
      74. /* 将栈顶返回 */  
      75. char Top(Stack S)  
      76. {  
      77.     if (!IsEmpty(S))  
      78.         return S->Array[S->Top_of_stack-1];  
      79.     printf("The Stack is empty! ");  
      80.     return 0;  
      81. }  
      82.   
      83. int main()  
      84. {  
      85.     int i, len;  
      86.     char str[100];  
      87.     printf("Please input the symbol that you want to balance:  ");  
      88.     scanf("%s", str);  
      89.     len = strlen(str);  
      90.     /* 根据序列的长度来创建栈 */  
      91.     struct Mystack *my_stack = CreateStack(len+1);  
      92.     for (i = 0; i < len; i++)  
      93.     {  
      94.         if (str[i] == '{' || str[i] == '[' || str[i] == '(' )  
      95.             Push(str[i], my_stack);  
      96.         if (str[i] == '}')  
      97.         {  
      98.             if (Top(my_stack) == '{')  
      99.                 Pop(my_stack);  
      100.             else  
      101.                 break;  
      102.         }  
      103.         else if (str[i] == ']')  
      104.         {  
      105.             if (Top(my_stack) == '[')  
      106.                 Pop(my_stack);  
      107.             else  
      108.                 break;  
      109.         }  
      110.         else if (str[i] == ')')  
      111.         {  
      112.             if (Top(my_stack) == '(')  
      113.                 Pop(my_stack);  
      114.             else  
      115.                 break;  
      116.         }  
      117.     }  
      118.     /* 如果最后占空则序列是合法的 */  
      119.     if(IsEmpty(my_stack))  
      120.         printf("The symbol that you input is balance! ");  
      121.     else  
      122.         printf("The symbol that you input is imbalance! ");  
      123.     DisposeStack(my_stack);  
      124.     return 0;  
      125. }  

      测试：

      [cpp] view plaincopy
       
      1. shang@shang:~/C$ ./a.out   
      2. Please input the symbol that you want to balance:   
      3. {[]}  
      4. The symbol that you input is balance!  
      5. shang@shang:~/C$ ./a.out   
      6. Please input the symbol that you want to balance:   
      7. [(])  
      8. The symbol that you input is imbalance!  
      9. shang@shang:~/C$ ./a.out   
      10. Please input the symbol that you want to balance:   
      11. ([{}])  
      12. The symbol that you input is balance!  
      13. shang@shang:~/C$  
      22. 用栈计算逆波兰式
        1. #include <stdio.h>  
        2. #include <stdlib.h>  
        3. #include <string.h>  
        4.   
        5. typedef struct Mystack *Stack;  
        6.   
        7. struct Mystack {  
        8.     int Capacity;       /* 栈的容量 */  
        9.     int Top_of_stack;   /* 栈顶下标 */  
        10.     int *Array;     /* 存放栈中元素的数组 */  
        11. };  
        12.   
        13. /* 栈的创建 */  
        14. Stack CreateStack(int Max)  
        15. {  
        16.     Stack S;  
        17.     S = malloc(sizeof(struct Mystack));  
        18.     if (S == NULL)  
        19.         printf("Create stack error! ");  
        20.   
        21.     S->Array = malloc(sizeof(char) * Max);  
        22.     if (S->Array == NULL)  
        23.         printf("Create stack error! ");  
        24.   
        25.     S->Capacity = Max;  
        26.     S->Top_of_stack = 0;  
        27.     return S;  
        28. }  
        29.   
        30. /* 释放栈 */  
        31. void DisposeStack(Stack S)  
        32. {  
        33.     if (S != NULL)  
        34.     {     
        35.         free(S->Array);  
        36.         free(S);  
        37.     }     
        38. }  
        39.   
        40. /* 判断一个栈是否是空栈 */  
        41. int IsEmpty(Stack S)  
        42. {  
        43.     return !S->Top_of_stack;  
        44. }  
        45.   
        46. /* 判断一个栈是否满栈 */  
        47. int IsFull(Stack S)  
        48. {  
        49.     if (S->Top_of_stack == S->Capacity - 1)  
        50.         return 1;  
        51.     else  
        52.         return 0;  
        53. }  
        54.   
        55.   
        56. /* 数据入栈 */  
        57. int Push(int x, Stack S)  
        58. {  
        59.     if (IsFull(S))  
        60.         printf("The Stack is full! ");  
        61.     else  
        62.         S->Array[S->Top_of_stack++] = x;  
        63. }  
        64.   
        65. /* 数据出栈 */  
        66. int Pop(Stack S)  
        67. {  
        68.     if (IsEmpty(S))  
        69.         printf("The Stack is empty! ");  
        70.     else  
        71.         S->Top_of_stack--;  
        72. }  
        73.   
        74. /* 将栈顶返回 */  
        75. int Top(Stack S)  
        76. {  
        77.     if (!IsEmpty(S))  
        78.         return S->Array[S->Top_of_stack-1];  
        79.     printf("The Stack is empty! ");  
        80.     return 0;  
        81. }  
        82.   
        83. int main()  
        84. {  
        85.     int i, len, result;  
        86.     char str[100];  
        87.     printf("Please input the postfix that you want to compute:  ");  
        88.     scanf("%s", str);  
        89.     len = strlen(str);  
        90.     /* 根据序列的长度来创建栈 */  
        91.     struct Mystack *my_stack = CreateStack(len+1);  
        92.     for (i = 0; i < len; i++)  
        93.     {  
        94.         if (str[i] >= '0' && str[i] <= '9')  
        95.             Push((int)str[i]-48, my_stack);  
        96.         else if (str[i] == '+')  
        97.         {  
        98.             int x = Top(my_stack);  
        99.             Pop(my_stack);  
        100.             int y =Top(my_stack);  
        101.             Pop(my_stack);  
        102.             Push(x+y, my_stack);  
        103.             //printf("%d ", Top(my_stack));  
        104.         }  
        105.         else if (str[i] == '-')  
        106.         {  
        107.             int x = Top(my_stack);  
        108.             Pop(my_stack);  
        109.             int y = Top(my_stack);  
        110.             Pop(my_stack);  
        111.             Push(x-y, my_stack);  
        112.             //printf("%d ", Top(my_stack));  
        113.         }  
        114.   
        115.         else if (str[i] == '*')  
        116.         {  
        117.             int x = Top(my_stack);  
        118.             Pop(my_stack);  
        119.             int y = Top(my_stack);  
        120.             Pop(my_stack);  
        121.             Push(x*y, my_stack);  
        122.             //printf("%d ", Top(my_stack));  
        123.         }  
        124.         else if (str[i] == '/')  
        125.         {  
        126.             int x = Top(my_stack);  
        127.             Pop(my_stack);  
        128.             int y = Top(my_stack);  
        129.             Pop(my_stack);  
        130.             Push(x/y, my_stack);  
        131.             //printf("%d ", Top(my_stack));  
        132.         }  
        133.     }  
        134.     printf("The result is: %d ", Top(my_stack));  
        135.     Pop(my_stack);  
        136.     /* A bug */  
        137. //  DisposeStack(my_stack);  
        138.   
        139.     return 0;  
        140.   
        141. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/tangtang-123/p/4436761.html