②泡茶看<数据结构>，喜欢看源码-栈ADT

前言

　　听着天籁，我是个音乐迷。时间充实着，会过得很快。我马上也可以到傍晚的时候去乐室吹我心爱的萨克斯。

　　　　　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　　　　　嘟嘟嘟... 我会吹一首简单的歌咯，哈哈我想到了一个神奇的比喻，待会说。

栈ADT模型（又称LIFO表）

　　栈（stack）插入和删除只能在一个位置上进行的表。该位置是表的末端但是叫做栈的顶（top）。基本操作：进栈（push相当于插入）和出栈（pop相当于删除）。又称LIFO表，后进先出。

　　　　　　相当于

　　　　　　　　　　　　　　　　　　　　就想快速呼吸一样。先吸进来的空气，先呼出去。

　　　　　　　　　　　　　　　　　　　　你是否记住了？

栈的源码和数组实现

　　java.util.Stack

　　 不得不申明下，小朽研究不深，如果大家看到了希望能指点指点我。有些时候，说错了，我马上会改正的。谢谢。先介绍类的结构图

　　　

　　　　下面是源码 java.util.Stack

 /*
  * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  *
  */

 package java.util;

 /**
  * The <code>Stack</code> class represents a last-in-first-out
  * (LIFO) stack of objects. It extends class <tt>Vector</tt> with five
  * operations that allow a vector to be treated as a stack. The usual
  * <tt>push</tt> and <tt>pop</tt> operations are provided, as well as a
  * method to <tt>peek</tt> at the top item on the stack, a method to test
  * for whether the stack is <tt>empty</tt>, and a method to <tt>search</tt>
  * the stack for an item and discover how far it is from the top.
  * <p>
  * When a stack is first created, it contains no items.
  *
  * <p>A more complete and consistent set of LIFO stack operations is
  * provided by the {@link Deque} interface and its implementations, which
  * should be used in preference to this class.  For example:
  * <pre>   {@code
  *   Deque<Integer> stack = new ArrayDeque<Integer>();}</pre>
  *
  * @author  Jonathan Payne
  * @since   JDK1.0
  */
 public
 class Stack<E> extends Vector<E> {
     /**
      * Creates an empty Stack.
      */
     public Stack() {
     }

     /**
      * Pushes an item onto the top of this stack. This has exactly
      * the same effect as:
      * <blockquote><pre>
      * addElement(item)</pre></blockquote>
      *
      * @param   item   the item to be pushed onto this stack.
      * @return  the <code>item</code> argument.
      * @see     java.util.Vector#addElement
      */
     public E push(E item) {
         addElement(item);

         return item;
     }

     /**
      * Removes the object at the top of this stack and returns that
      * object as the value of this function.
      *
      * @return  The object at the top of this stack (the last item
      *          of the <tt>Vector</tt> object).
      * @throws  EmptyStackException  if this stack is empty.
      */
     public synchronized E pop() {
         E       obj;
         int     len = size();

         obj = peek();
         removeElementAt(len - 1);

         return obj;
     }

     /**
      * Looks at the object at the top of this stack without removing it
      * from the stack.
      *
      * @return  the object at the top of this stack (the last item
      *          of the <tt>Vector</tt> object).
      * @throws  EmptyStackException  if this stack is empty.
      */
     public synchronized E peek() {
         int     len = size();

         if (len == 0)
             throw new EmptyStackException();
         return elementAt(len - 1);
     }

     /**
      * Tests if this stack is empty.
      *
      * @return  <code>true</code> if and only if this stack contains
      *          no items; <code>false</code> otherwise.
      */
     public boolean empty() {
         return size() == 0;
     }

     /**
      * Returns the 1-based position where an object is on this stack.
      * If the object <tt>o</tt> occurs as an item in this stack, this
      * method returns the distance from the top of the stack of the
      * occurrence nearest the top of the stack; the topmost item on the
      * stack is considered to be at distance <tt>1</tt>. The <tt>equals</tt>
      * method is used to compare <tt>o</tt> to the
      * items in this stack.
      *
      * @param   o   the desired object.
      * @return  the 1-based position from the top of the stack where
      *          the object is located; the return value <code>-1</code>
      *          indicates that the object is not on the stack.
      */
     public synchronized int search(Object o) {
         int i = lastIndexOf(o);

         if (i >= 0) {
             return size() - i;
         }
         return -1;
     }

     /** use serialVersionUID from JDK 1.0.2 for interoperability */
     private static final long serialVersionUID = 1224463164541339165L;
 }

java.util.Stack

　　　　①Pushes an item onto the top of this stack.

public E push(E item) {
        addElement(item);
        return item;
    }

　　　　从类的结构图可以看出,addElement是Stack父类Vector封装，用于一切其子类的封装。

　　　　　#Adds the specified component to the end of this vector

public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }

ad

　　　　②Removes the object at the top of this stack and returns the onject that object as the value of this function

public synchronized E pop() {
        E       obj;
        int     len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

　　　　　同样，跟addElement一样removeElementAt存在Vector

　　　　　　　#Deletes the component at the specified index.

 public synchronized void removeElementAt(int index) {
        modCount++;
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        int j = elementCount - index - 1;
        if (j > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        elementCount--;
        elementData[elementCount] = null; /* to let gc do its work */
    }

　　　　　But,这个是什么 peek（），别慌它也是存在Stack类中下面我们讲这个

　　　　③Looks at the object at the top of this stack without remocing it

public synchronized E peek() {
        int     len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

　　　　　　跟addElement,removeElementAt一样，elementAt存在Vector

　　　　　　　　#Returns the component at the specified index.

public synchronized E elementAt(int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
        }

        return elementData(index);
    }

　　　④Tests if this stack is empty

public boolean empty() {
        return size() == 0;
    }

　　　　size() 来源于Vector,用于获取大小

　　　⑤Stack中其他，就不做介绍罗列下

　　　　void　Stack()　　//create an empty stack
　　　　int　search(Object o)　　//return the 1 - based position where an obj is on this stack

　　数组实现

package sedion.jeffli.bean;

/**
 * qq 1928348753
 * blog http://www.cnblogs.com/Alandre/
 * @author Jeff Li
 */
public class myS {       

  Object[] data; 

  int maxSize;
  int top;       

  public myS(int maxSize) {
      this.maxSize = maxSize;
      data = new Object[maxSize];
      top = -1;
  }       

  /**
   * 获取堆栈长度
   * @return 堆栈长度
   */
  public int getSize()
  {
    return maxSize;
  } 

  /**
   * 返回栈中元素的个数
   * @return 栈中元素的个数
   */
  public int getElementCount()
  {
    return top;
  } 

  /**
   * 判断栈空
   * @return 栈空
   */
  public boolean isEmpty()
  {
    return top == -1;
  } 

  /**
   * 判断栈满
   * @return 栈满
   */
  public boolean isFull()
  {
    return top+1 == maxSize;
  } 

  /**
   * 依次加入数据
   * @param data 加入的数据
   * @return 添加是否成功
   */
  public boolean push(Object data) {
    if(isFull())
    {
        System.out.println("栈已满!");
        return false;
    }
    this.data[++top] = data;
    return true;
  }       

  /**
   * 从栈中取出数据
   * @return 取出的数据
   */
  public Object pop() throws Exception{
    if(isEmpty())
    {
        throw new Exception("栈已空!");
    }
    return this.data[top--];
  }       

  /**
   * 返回栈顶元素
   * @return
   */
  public Object peek()
  {
    return this.data[getElementCount()];
  } 

  public static void main(String[] args) throws Exception {
      myS stack=new myS(1000);
      stack.push(new String("1"));
      stack.push(new String("2"));
      stack.push(new String("3"));
      stack.push(new String("4"));
      stack.push(new String("5"));   

      System.out.println("栈顶元素"+stack.peek());  

      while(stack.top>=0)
      {
          System.out.println("Position["+stack.top+"]:"+stack.pop());
      }
  }
} 

栈的应用

　　　　四则运算，计算器编程。这些，我想原理才是重要的。

　　　　这是一些资料共享应用　　

　　　　　　　　http://blog.sina.com.cn/s/blog_69e8f4c20101308b.html

　　　　　　　　http://justsee.iteye.com/blog/1125174　　　

　　

寄读者，寄知识来源

　　　读者，你好！你我不相识，谢谢你们支持。我的梦想会越来越接近。keep on，共勉！

　　　知识来源　http://book.douban.com/doulist/3563883/　　

　　　　　　　　http://www.cnblogs.com/shitianzeng/articles/2336765.html