大话数据结构读书笔记（四）-栈和队列

来源：互联网发布：淘宝哪个店铺能套现编辑：程序博客网时间：2024/04/28 04:49

四、栈和队列

栈：是限定仅在表尾进行插入和删除操作的线性表。把允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈。栈又称为后进先出的线性表，简称LIFO结构。（线性表就有线性表的性质）
栈的插入操作，叫做进栈，也称压栈、入栈。
栈的删除操作，叫做出栈，也称弹栈。（通项计算C(2n,n)/(n+1)。

栈顶：top无元素是-1，（出栈和进栈不涉及循环时间复杂度O(1)）。两栈共享空间：top1+1==top2栈满。

栈得链式存储：链栈基本不存在栈满。

栈得应用：1、递归（斐波那契数列），直接调用自己或者通过语句间接调用自己的函数。2、四则运算表达式求值（逆波兰：一种不需要括号的后缀表达式）表达式：9 3 1 – 3 * + 10 2 / +。规则：从左到右遍历表达式中的每个数字和符号，遇到是数字就进栈，遇到事符号就就将栈顶两个数字取出进行计算，运算结果进栈，一直到最终获得结果。

中缀表达式转后缀表达式：中缀表达式“9+(3-1)*3+10/2”转化为后缀表达式“9 3 1 3 – 3 * + 10 2 / +” 规则：从左到右遍历表达式的每个数字和符号，若是数字就输出，就成为后缀表达式的一部分；若是符号，则判断与其栈顶符号的优先级，是右括号或者优先级低于栈顶元素则栈顶元素以此出栈并输出，并将当前符号进栈，一直到最终输出后缀表达式。

队列：只允许在一段进行插入操作，而在另一端进行删除操作的线性表。队列是一种先进先出的线性表，简称FIFO。允许插入的一段陈为队尾，允许删除的一段称为对头。

循环队列：我们把队列头尾相接的顺序存储结构称为循环队列。单链队列时，当队列为空时，front等于rear，现在循环队列当队列满时，也是front等于rear，怎么判断为空还是满，加标志位。若队列的最大尺寸为QueueSize，那么队列满的条件是(rear + 1) % QueueSize == front。

队列的链式存储：队列的链式存储结构其实就是线性表的单链表，只不过它只能头出尾进，我们把它简称为队列。
栈得基本操作：

package day01to05;interface statck{      public boolean push(Object x);//入栈操作      public int length();      public Object peek();//取栈顶元素      public Object pop() throws Exception; //出战操作      public Object min(); //取栈中的最小值     public void reverseStack(stack s)throws Exception; //将栈中元素颠倒    public void clear();      public boolean isEmpty();}public class stack implements statck{private int[] Index;      private Object[] stackElem;      public Object[] getStackElem() {          return stackElem;      }      public int[] getmIndex() {          return Index;      }      private int top;       public stack(int maxSize) {          stackElem = new Object[maxSize];          Index = new int[maxSize];          top = 0;      }       public void clear() {          // TODO Auto-generated method stub          top = 0;      }        public boolean isEmpty() {          // TODO Auto-generated method stub          return top == 0;//当top为0，栈为空；      }        public int length() {          // TODO Auto-generated method stub          return top;      }        // 取栈顶元素的函数      public Object peek() {          // TODO Auto-generated method stub          if (!isEmpty())              return stackElem[top - 1];//top指向新元素即将放在的位置，所以top-1为栈顶元素。          else              return null;      }      /**      * 进栈操作 要求：时间复杂度是O(1)      * */      public boolean push(Object x) {          // TODO Auto-generated method stub          if (top == stackElem.length) {              System.out.print("栈已满");              return false;          }          if (top == 0) {              Index[top] = 0;          } else if ((Integer)x <(Integer)peek()&& peek() != null) {              Index[top] = top;          } else if (peek() != null) {              Index[top] = Index[top - 1];          }          stackElem[top++] = x;          return true;      }        /**      * 顺序栈的出栈操作 时间复杂度为：O(1)      * */      public Object pop() throws Exception {          // TODO Auto-generated method stub          if (!isEmpty()) {// 若栈不空，则移去栈顶元素并返回其值              Index[top - 1] = -1;              return stackElem[--top];          } else              return null;// 若栈空，则返回空值      }      /**      * 返回栈中最小的元素，需要一个辅助栈 要求：时间复杂度是O(1) 解决这道题的思路在于：用空间换时间！      * */      public Object min() {          if (top == 0)              return null;          else              return stackElem[Index[top - 1]];       }       @Override      /**      * 要求用递归的方法，在不浪费空间的情况下，颠倒栈。      * */      public void reverseStack(stack s) throws Exception {          if (!s.isEmpty()) {              Object t = s.pop();              reverseStack(s);              pushStackButtom(s, t);          }      }      public void pushStackButtom(stack s, Object t) throws Exception {          if (s.isEmpty()) {              s.push(t);          } else {              Object top = s.pop();              pushStackButtom(s, t);              s.push(top);          }      }   }

队列的基本操作：

 interface Que {  public void clear();  public boolean isEmpty();  public int length();  public Object peek();  //取栈顶元素  public void enQueue(Object x)throws Exception;//入队操作  public Object deQueue();//出队操作  }  //第一种：顺序队列的基本操作的实现/**   * 本类针对顺序队列   * */  public class Quene implements Que {      private Object[] q;      private int head, tail;      public Quene(int maxSize) {          q = new Object[maxSize];          head =0;          tail = 0;      }      public Object[] getQ() {          return q;      }      @Override      public void clear() {          // TODO Auto-generated method stub        }       @Override      public boolean isEmpty() {          return false;      }        @Override      public int length() {          return tail;      }      @Override      public Object peek() {          if (!isEmpty())              return q[tail - 1];          return null;      }      @Override      public void enQueue(Object x) throws Exception {          if (tail == q.length)              throw new Exception("队列已满");          q[tail++] = x;        }       @Override      public Object deQueue() {          if (!isEmpty())              return q[head++];          else              return null;      }   }

0 0