算法导论第四版学习——习题二Deques and Randomized Queues

题目正文：

http://coursera.cs.princeton.edu/algs4/assignments/queues.html

作业难点：

1、选择使用链表还是数组，将会是第一个问题，选择合适会减少很多工作量。

2、并行从RandomizedQueue中取两个枚举，这两个枚举必须是不一样的，所以有很多偷懒的“伪随机”是行不通的。

3、SubSet仅需K存储而不是N存储，即可实现。（这个我也没想到方法实现）

作业技巧：

1、可遍数组和邻接节点两种数据结构都已经给你了，你只要改改，基本上实现第一个Deque没有任何难度

2、RandomizedQueue涉及到一个基本面试题问题，如果有一个0到100的数组，随机取不重复的元素，如何实现？

从大小为N的数组A中随机[0,N)取下标x的元素A[x]，让A[x]与A[N-1]交换，再随机[0,N-1)取下标x的元素A[y]与A[N-2]交换，以此类推。

3、无论是编译还是网站测试都会报警数组泛型的问题，这个可以百度，JAVA数组不支持泛型。对于作业来说忽略就好了。

代码参考：

（这是我自己亲测100分的答案，不代表写得最好，请在自己实在完成不了的时候再看，不然的话做这个题目的意义一点都没有）

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;

import java.util.Iterator;
import java.util.NoSuchElementException;


public class Deque<Item> implements Iterable<Item> {
    private int n;
    private Node first;
    private Node last;

    public Deque() // construct an empty deque
     {
        n = 0;
        first = null;
        last = null;
    }

    public boolean isEmpty() // is the deque empty?
     {
        return first == null;
    }

    public int size() // return the number of items on the deque
     {
        return n;
    }

    public void addFirst(Item item) // add the item to the front
     {
        if (item == null) {
            throw new NullPointerException();
        }

        Node oldfirst = first;
        first = new Node();
        first.item = item;
        first.next = oldfirst;

        if (oldfirst == null) {
            last = first;
        } else {
            oldfirst.prev = first;
        }

        n++;
    }

    public void addLast(Item item) // add the item to the end
     {
        if (item == null) {
            throw new NullPointerException();
        }

        Node oldlast = last;
        last = new Node();
        last.item = item;
        last.prev = oldlast;

        if (oldlast == null) {
            first = last;
        } else {
            oldlast.next = last;
        }

        n++;
    }

    public Item removeFirst() // remove and return the item from the front
     {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }

        Item item = first.item;
        first = first.next;

        if (first == null) {
            last = null;
        } else {
            first.prev = null;
        }

        n--;

        return item;
    }

    public Item removeLast() // remove and return the item from the end
     {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }

        Item item = last.item;
        last = last.prev;

        if (last == null) {
            first = null;
        } else {
            last.next = null;
        }

        n--;

        return item;
    }

    public Iterator<Item> iterator() // return an iterator over items in order from front to end
     {
        return new DequeIterator();
    }

    public static void main(String[] args) // unit testing
     {
        Deque<String> deque = new Deque<String>();

        while (!StdIn.isEmpty()) {
            String item = StdIn.readString();

            if (item.equals("+")) {
                item = StdIn.readString();
                deque.addFirst(item);
            } else if (item.equals("++")) {
                item = StdIn.readString();
                deque.addLast(item);
            } else if (item.equals("exit")) {
                break;
            } else if (item.equals("show")) {
                for (String s : deque) {
                    StdOut.println(s);
                }
            } else if (item.equals("-")) {
                if (!deque.isEmpty()) {
                    StdOut.print(deque.removeFirst() + " ");
                }
            } else if (item.equals("--")) {
                if (!deque.isEmpty()) {
                    StdOut.print(deque.removeLast() + " ");
                }
            }
        }

        StdOut.println("(" + deque.size() + " left on deque)");
    }

    private class DequeIterator implements Iterator<Item> {
        private Node current = first;

        public boolean hasNext() {
            return current != null;
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

        public Item next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }

            Item item = current.item;
            current = current.next;

            return item;
        }
    }

    private class Node {
        private Item item;
        private Node next;
        private Node prev;
    }
}

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;

import java.util.Iterator;
import java.util.NoSuchElementException;


public class RandomizedQueue<Item> implements Iterable<Item> {
    private Item[] a; // array of items
    private int n; // number of elements on stack

    public RandomizedQueue() // construct an empty randomized queue
     {
        a = (Item[]) new Object[2];
        n = 0;
    }

    public boolean isEmpty() // is the queue empty?
     {
        return n == 0;
    }

    public int size() // return the number of items on the queue
     {
        return n;
    }

    // resize the underlying array holding the elements
    private void resize(int capacity) {
        assert capacity >= n;

        Item[] temp = (Item[]) new Object[capacity];

        for (int i = 0; i < n; i++) {
            temp[i] = a[i];
        }

        a = temp;
    }

    public void enqueue(Item item) // add the item
     {
        if (item == null) {
            throw new NullPointerException();
        }

        if (n == a.length) {
            resize(2 * a.length); // double size of array if necessary
        }

        a[n++] = item; // add item
    }

    public Item dequeue() // remove and return a random item
     {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }

        int targetid = StdRandom.uniform(0, n);
        Item item = a[targetid];
        a[targetid] = a[n - 1];
        a[n - 1] = null; // to avoid loitering
        n--;

        // shrink size of array if necessary
        if ((n > 0) && (n == (a.length / 4))) {
            resize(a.length / 2);
        }

        return item;
    }

    public Item sample() // return (but do not remove) a random item
     {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }

        int targetid = StdRandom.uniform(0, n);

        return a[targetid];
    }

    public Iterator<Item> iterator() // return an independent iterator over items in random order
     {
        return new RandomizedQueueIterator();
    }

    public static void main(String[] args) // unit testing
     {
        RandomizedQueue<String> queue = new RandomizedQueue<String>();

        while (!StdIn.isEmpty()) {
            String item = StdIn.readString();

            if (item.equals("-") && !queue.isEmpty()) {
                StdOut.print(queue.dequeue() + " ");
            }
            else if (item.equals("--") && !queue.isEmpty()) {
                StdOut.print(queue.sample() + " ");
            }
            else if (item.equals("show")) {
                for (String s : queue) {
                    StdOut.println(s);
                }
            }
            else if (item.equals("size")) {
                StdOut.println("(" + queue.size() + " left on stack)");
            }
            else if (item.equals("exit")) {
                break;
            } 
            else {
                queue.enqueue(item);
            }
        }

        StdOut.println("(" + queue.size() + " left on stack)");
    }

    private class RandomizedQueueIterator implements Iterator<Item> {
        private int i;
        private Item[] temp;

        public RandomizedQueueIterator() {
            i = n - 1;
            temp = (Item[]) new Object[a.length];
            for (int j = 0; j < n; j++) {
                temp[j] = a[j];
            }
        }

        public boolean hasNext() {
            return i >= 0;
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

        public Item next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }

            int targetid = StdRandom.uniform(0, i + 1);
            Item item = temp[targetid];
            temp[targetid] = temp[i];
            temp[i] = item;
            i--;
            return item;
        }
    }
}

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;
public class Subset {
    public static void main(String[] args) {
        RandomizedQueue<String> queue = new RandomizedQueue<String>();
        int num = Integer.parseInt(args[0]);

        while (!StdIn.isEmpty()) {
            String item = StdIn.readString();
            // if (item.equals("exit")) {
            //    break;
            // } 
            queue.enqueue(item);
        }

        for (String s : queue) {
            if (num == 0) {
                break;
            }

            StdOut.println(s);
            num--;
        }
    }
}