《算法导论》chapter 10

基本的数据结构有4种，栈，队列，链表，有根树，栈和队列都属于动态集合。

 

关于栈（stack）

栈有2种基本操作

• pop()
• push()

pop()是弹出，push()压入

栈是一种先进后出的策略(last-in, first-out, LIFO)，举个栗子，小明整理箱子，小明的《热恋天堂》是最先放在箱子了，这个时候，他想看《热恋天堂》了，但是书在最下面，于是他只能把其他东西pop()，才能拿到《热恋天堂》。

再拿数组来举个栗子，比如说数组S[0-n]，如果想要得到S[0],那其他的元素只能pop()掉其他数组元素。

如果栈的位置不够了，再继续插入就会出现栈上溢出的错误(overflow)，对空栈进行pop()会发生栈下溢出，其实这个很好理解，举个栗子(x3)，如果你让一个16g的手机存20g的电影，肯定是不可能的，系统也会给出提示告诉你内存不足，同样的，一个土豪有100w，（土豪应该不止这么点 = =），有一天他脑抽了，一口气把钱花完了，然后想去买瓶水，然后发现钱不够了。

 

Java实现的栈(最简单的一种)

 public class Stack {

    /**
     * top : 栈的长度
     * push : 压入元素
     * pop : 弹出元素
     * 栈的原理是先进后出，(last-in,first-out,LIFO),栈每次弹出都是最近压入的元素
     *top指向栈顶
     */

  int S[] = new int[7];
  int top;

  boolean Empty()
  {
      if (top == 0)
      {
          return true;
      }
      else
      {
          return false;
      }
  }

  boolean push(int x)
  {
   if (top>=S.length-1)
   {
       System.out.println("Overflow");
       return true;
   }
   else
   {
       top = top+1;
       S[top] = x;
       return true;
   }
  }

  int pop()
  {
      if (top<0)
      {
          System.out.println("Underflow");
          return 0;
      }
      else
      {
          int x = S[top--];
          return x;
      }
  }
}

 

队列

 

队列和栈其实差不多，都是线性表，有两种基本操作，入队，出队，队列的概念是(first-in, first-out FIFO)先进先出，队列相对来说比栈好理解一点(个人感觉)，超市结账和队列一样，谁先过来，谁先结账，

队列有队头和队尾，新进来的顾客要结账是在队尾的位置上，要结账的人是在队头，队列也会有上溢出和下溢出，这点和栈一样。

 

Java实现的队列(最简单的一种)

public class Queue {

    /**
     * 队列特性是 先进先出(first-in first-out FIFO)
     * Insert : 入队
     * Delete : 删除
     * head  :  队头
     * tail :   队尾
     * capacity : 数组大小
     * 队列插入是在队尾插入，出队是第
     */

    int [] Q;
    private int head;
    private int tail;
    private int size;
    private int capacity;
    public Queue(int capacity)
    {
        this.capacity = capacity;
        tail = this.size = 0;
        head = capacity-1;
        Q = new int[this.capacity];
    }

    /**
     * 判断队列还能不能继续入队
     */

    boolean isFull(Queue queue)
    {
        return (queue.size == queue.capacity);
    }

    boolean isEmpty(Queue queue)
    {
        return (queue.size == 0);
    }

    void  enqueue(int item)
    {
        if (isFull(this))
            return;
        this.head = (this.tail+1) % this.capacity;
        this.Q[this.head] = item;
        this.size = this.size+1;
        System.out.println(item+ " enqueued to queue");
    }

    int deque()
    {
        if (isEmpty(this))
            return Integer.MIN_VALUE;
        int item = this.Q[this.tail];
        this.tail = (this.tail+1) % this.capacity;
        this.size = this.size-1;
        return item;
    }

    int tail()
    {
        if (isEmpty(this))
        {
                return Integer.MIN_VALUE;
        }
        return this.Q[this.tail];
    }

    int head()
    {
        if (isEmpty(this))
        {
                return Integer.MIN_VALUE;
        }
        return this.Q[this.head];
    }

}