《算法》1.3背包、队列和栈

1、基本概念

背包：Bag

• 背包是一种不支持从中删除元素的集合类型。
• 目的是收集元素并迭代遍历所有收集到的元素。
• 迭代的顺序不确定且与用例无关。

队列：Queue

• 先进先出
• 入列顺序与出列顺序相同

栈：Stack

• 后进先出
• 元素的处理顺序与他们被压入的顺序正好相反

2、实现

2.1基于数组实现

栈：

import java.util.Iterator;
import java.util.Objects;

/**
 * 基于数组实现的栈，能够动态调整数组大小。
 * @Author: AZhu18
 * @Date: 2021/2/5 23:48
 */
public class ResizingArrayStack<Item> implements Iterable<Item> {

    private Item[] a = (Item[]) new Objects[1];//栈元素
    private int N = 0;//元素的数量

    public boolean isEmpty() {
        return N == 0;
    }
    public int size() {
        return N;
    }

    private void resize(int max) {
        //将栈移动到一个大小为max的新数组
        Item[] temp = (Item[]) new Objects[max];
        for (int i = 0; i < N; i++) {
            temp[i] = a[i];
        }
        a = temp;
    }

    public void push(Item item) {
        if (N==a.length) resize(2 * a.length);
        a[N++] = item;
    }
    public Item pop() {
        Item item = a[--N];
        a[N] = null;
        if (N > 0 && N == a.length / 4) {
            resize(a.length / 2);
        }
        return item;
    }

    public Iterator<Item> iterator() {
        return new ReverseArrayIterator();
    }
    /**
     * 支持后进先出的迭代
     */
    private class ReverseArrayIterator implements Iterator<Item> {
        private int i = N;
        @Override
        public boolean hasNext() {
            return i > 0;
        }
        @Override
        public Item next() {
            return a[--i];
        }
    }

}

2.2基于链表实现

栈：

import java.util.Iterator;

/**
 * 基于链表实现的栈。
 * @Author: AZhu
 * @Date: 2021/2/6 0:12
 */
public class Stack<Item> implements Iterable<Item> {

    private Node first;//栈顶元素
    private int N = 0;//元素的数量
    //定义了结点的嵌套类
    private class Node {
        Item item;
        Node next;
    }

    public boolean isEmpty() {
        return N == 0;
    }
    public int size() {
        return N;
    }

    public void push(Item item) {
        Node oldFirst = first;
        first = new Node();
        first.item = item;
        first.next = oldFirst;
        N++;
    }
    public Item pop() {
        Item item = first.item;
        first = first.next;
        N--;
        return item;
    }

    @Override
    public Iterator<Item> iterator() {
        return new TraverseListIterator();
    }

    private class TraverseListIterator implements Iterator<Item> {
        private Node p = first;
        @Override
        public boolean hasNext() {
            return p.next != null;
        }
        @Override
        public Item next() {
            Item item = p.item;
            p = p.next;
            return item;
        }
    }
}

队列：

import java.util.Iterator;

/**
 * 基于链表实现的队列
 * @Author: AZhu
 * @Date: 2021/2/6 0:37
 */
public class Queue<Item> implements Iterable<Item> {

    private Node first;//队头
    private Node last;//队尾
    private int N;//元素的数量
    //定义了结点的嵌套类
    private class Node {
        Item item;
        Node next;
    }

    public boolean isEmpty() {
        return first == null;
    }

    public int size() {
        return N;
    }

    public void enqueue(Item item) {
        Node oldLast = last;
        last = new Node();
        last.item = item;
        last.next = null;
        if (isEmpty()) {
            first = last;
        } else {
            oldLast.next = last;
        }
        N++;
    }

    public Item dequeue() {
        Item item = first.item;
        first = first.next;
        if (isEmpty()) {
            last = null;
        }
        N--;
        return item;
    }

    @Override
    public Iterator<Item> iterator() {
        return new TraverseListIterator();
    }

    private class TraverseListIterator implements Iterator<Item> {
        private Node p = first;
        @Override
        public boolean hasNext() {
            return p.next != null;
        }
        @Override
        public Item next() {
            Item item = p.item;
            p = p.next;
            return item;
        }
    }
}

背包：

import java.util.Iterator;

/**
 * 基于链表实现的背包
 * @Author: AZhu
 * @Date: 2021/2/6 0:52
 */
public class Bag<Item> implements Iterable<Item> {

    private Node first;//链表的首结点
    //定义了结点的嵌套类
    private class Node {
        Item item;
        Node next;
    }

    public void add(Item item) {
        Node oldFirst = first;
        first = new Node();
        first.item = item;
        first.next = oldFirst;
    }

    @Override
    public Iterator<Item> iterator() {
        return new TraverseListIterator();
    }

    private class TraverseListIterator implements Iterator<Item> {
        private Node p = first;
        @Override
        public boolean hasNext() {
            return p.next != null;
        }
        @Override
        public Item next() {
            Item item = p.item;
            p = p.next;
            return item;
        }
    }
}