算法与数据结构 04 队列

1. 队列

• 队列是另一种特殊的线性表，他的特殊性体现在队列只允许在表尾插入数据元素，在表头删除数据元素。它具有先进先出后后进后出的特性。
• 我们把允许删除的一端称为队首（front），插入的一端称为队尾（rear）
  不含任何数据元素的队列称为空队列。
• 队列的插入操作，叫作入队；队列的删除操作，叫作出队。
• 队列也是由n（n>=0）个具有相同类型的数据元素所构成的有限序列。其几本操作与栈类似：
  （1）清空队列 clear（）：将一个已经存在的队列置为空
  （2）判空操作 isEmpty（）：判断一个数列是否为空，若为空，则返回true；不为空，则返回false；
  （3）求队列长度 length（）：返回队列中数据元素的个数
  （4） 取队首元素 peek（）：读取对首元素并返回数值
  （5） 入队操作 offer（）：将新的数据元素插入队列中并使其成为新的队尾元素
  （6）出队操作 poll（）：删除队首元素并返回其值，若队列为空，则返回null；
  用Java接口描述：

public interface Queue<E> extends Iterable<E> {
  public void offer(E element);   //入队
  public E poll();    //出队
  public E peek();    //查看队首元素
  public boolean isEmpty();
  public void clear();
  public int size();
}

• 队列也有顺序和链式两种存储结构。顺序存储结构的队列称为顺序队列，链式存储结构的队列称为链队列。
  代码实现：

public class ArrayQueue <E> implements Queue<E> {
  private ArrayList<E> list;
  public ArrayQueue() {
    list = new ArrayList<>();
  }

  @Override
  public void offer(E element) {
    list.add(list.size(), element);
  }

  @Override
  public E poll() {
    return list.remove(0);
  }

  @Override
  public E peek() {
    return list.get(0);
  }

  @Override
  public boolean isEmpty() {
    return list.isEmpty();
  }

  @Override
  public void clear() {
    list.clear();
  }

  @Override
  public int size() {
    return list.size();
  }

  @Override
  public Iterator<E> iterator() {
    return list.iterator();
  }

  @Override
  public String toString() {
    return list.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (o == null) {
      return false;
    }
    if (this == o) {
      return true;
    }
    if (o instanceof ArrayQueue) {
      ArrayQueue other = (ArrayQueue) o;
      return list.equals(other.list);
    }
    return false;
 }

2. 用栈实现队列

创建两个栈，一个用来放数据（数据栈），一个用来辅助（辅助栈）。数据添加时，会依次压人栈，取数据时肯定会取栈顶元素，但我们想模拟队列的先进先出，所以就得取栈底元素，那么辅助栈就派上用场了，把数据栈的元素依次弹出到辅助栈，但保留最后一个元素，最后数据栈就剩下了最后一个元素，直接把元素返回，这时数据栈已经没有了数据。最后呢，把辅助栈的元素依次压人数据栈，这样，我们成功取到了栈底元素。
代码实现：

public static void main(String[] args) {
    QueueImplByStack<Integer> queue = new QueueImplByStack<>();
    for (int i = 1; i <= 5; i++) {
      queue.offer(i);
    }
    System.out.println(queue);
    System.out.println(queue.poll());
    System.out.println(queue);
  }
}
class QueueImplByStack<E> implements Queue<E> {
  private ArrayStack<E> stackA;
  private ArrayStack<E> stackB;
  public QueueImplByStack() {
    stackA = new ArrayStack<>();
    stackB = new ArrayStack<>();
  }

  @Override
  public void offer(E element) {
    stackA.push(element);
  }

  @Override
  public E poll() {
    if (isEmpty()) {
      throw new IllegalArgumentException("queue is null");
    }
    while (stackA.size() != 1) {
      stackB.push(stackA.pop());
    }
    E ret = stackA.pop();

    while (!stackB.isEmpty()) {
      stackA.push(stackB.pop());
    }
    return ret;
  }

  @Override
  public E peek() {
    if (isEmpty()) {
      throw new IllegalArgumentException("queue is null");
    }
    while (stackA.size() != 1) {
      stackB.push(stackA.pop());
    }
    E ret = stackA.peek();

    while (!stackB.isEmpty()) {
      stackA.push(stackB.pop());
    }
    return ret;
  }

  @Override
  public boolean isEmpty() {
    return stackA.isEmpty();
  }

  @Override
  public void clear() {
    stackA.clear();
  }

  @Override
  public int size() {
    return stackA.size();
  }

  @Override
  public Iterator<E> iterator() {
    return stackA.iterator();
  }

  @Override
  public String toString() {
    return stackA.toString();
  }
}

3. 队列实现栈

思路与上面差不多：有数据队列和辅助队列，模拟栈的先进后出，队列是队尾进队首出，也就是说每次取值要取队尾元素，数据队列出队到辅助队列，留下最后一个元素返回，辅助队列再把元素出队到数据队列

代码实现：

public class QueueToStack {
  public static void main(String[] args) {
    StackImplByQueue<Integer> stack = new StackImplByQueue<>();
    System .out.println(stack);
    for (int i = 1; i <= 5; i++) {
      stack.push(i); //队列A
    }
    System .out.println(stack.toString());
    System .out.println(stack.pop());
    System .out.println(stack);  //队列B

  }
}
class StackImplByQueue<E> implements Stack<E> {
  private ArrayQueue<E> queueA;
  private ArrayQueue<E> queueB;

  public StackImplByQueue() {
    queueA = new ArrayQueue<>();
    queueB = new ArrayQueue<>();
  }

  @Override
  public int size() {
    if (queueA.isEmpty() && queueB.isEmpty()) {
      return 0;
    } else if (!queueA.isEmpty()) {
      return queueA.size();
    } else {
      return queueB.size();
    }
  }

  @Override
  public boolean isEmpty() {
    return queueA.isEmpty() && queueB.isEmpty();
  }

  @Override
  public void push(E element) {
    if (queueA.isEmpty() && queueB.isEmpty()) {
      queueA.offer(element);
    } else if (!queueA.isEmpty()) {
      queueA.offer(element);
    } else {
      queueB.offer(element);
    }
  }

  @Override
  public E pop() {
    if (isEmpty()) {
      return null;
    }
    E ret = null;
    if (!queueA.isEmpty()) {
      while (queueA.size() != 1) {
        queueB.offer(queueA.poll());
      }
      ret = queueA.poll();
    } else {
      while (queueB.size() != 1) {
        queueA.offer(queueB.poll());
      }
      ret = queueB.poll();
    }
    return ret;
  }

  @Override
  public E peek() {
    if (isEmpty()) {
      return null;
    }
    E ret = null;
    if (!queueA.isEmpty()) {
      while (queueA.size() != 1) {
        queueB.offer(queueA.poll());
      }
      ret = queueA.poll();
      queueB.offer(ret);
    } else {
      while (queueB.size() != 1) {
        queueA.offer(queueB.poll());
      }
      ret = queueB.poll();
      queueA.offer(ret);
    }
    return ret;
  }

  @Override
  public void clear() {
    queueA.clear();
    queueB.clear();
  }

  @Override
  public Iterator<E> iterator() {
    if (isEmpty()) {
      return queueA.iterator();
    } else if (!queueA.isEmpty()) {
      return queueA.iterator();
    } else {
      return queueB.iterator();
    }
  }
  @Override
  public String toString() {
    if (isEmpty()) {
      return "[]";
    } else if (!queueA.isEmpty()) {
      return queueA.toString();
    } else {
      return queueB.toString();
    }
  }

4. 队列的应用之文件夹的遍历

1.起始状态先把一级目录文件夹A放进队列中

2.然后开始判断队列是否为空

3.若队列不为空，进行出队操作

4.对出队的文件夹进行展开遍历

5.若遍历到文件则直接打印文件名

6.若遍历到文件夹则进行入对操作

7.接着判断队列是否为空，不为空接着出队，展开文件夹，遍历。

8.直到队列为空为止

public class DirectoryTraversal {
  public static void main(String[] args) {
    /*
     * 只要队列不为空 则出队一个目录对象
     * 将该目录对象展开 开始遍历 遇到文件则打印名称 遇到其他目录 则进队
     * */
    File dir = new File("文件夹地址");
    QueueImplByStack<File> queue = new QueueImplByStack<>();
    queue.offer(dir);
    while (!queue.isEmpty()) {
      File file = queue.poll();
      System.out.println("【" + file.getName() + "】");
      File[] files = file.listFiles();
      for (File f : files) {
        if (f.isFile()) {
          System.out.println(f.getName());
        } else {
          queue.offer(f);
        }
      }
    }
  }
}