Programming Assignment: Deques and Randomized Queues

Deque.java

import java.util.Iterator;

/**
 * Created by LK on 2017/4/4.
 */
public class Deque<Item> implements Iterable<Item> {


    private int size;
    private Node<Item> first;
    private Node<Item> last;

    public Deque()                           // construct an empty deque
    {
        this.first = new Node<Item>(null);
        this.last = new Node<Item>(null);
        first.next = last;
        last.pre = first;
        this.size = 0;
    }


    private class Node<Item> {
        private Item item;
        private Node<Item> next;
        private Node<Item> pre;

        private Node(Item item) {
            this.item = item;
            next = null;
            pre = null;
        }
    }


    private class DequeIterator implements Iterator<Item> {

        private Node<Item> current = first.next;

        @Override
        public boolean hasNext() {
            return current != last;
        }

        @Override
        public Item next() {
            if (last == current)
                throw new java.util.NoSuchElementException();
            Item item = current.item;
            current = current.next;
            return item;
        }

        @Override
        public void remove() {
            throw new java.lang.UnsupportedOperationException();
        }
    }

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


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

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

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

        Node<Item> n = first.next;

        Node<Item> node = new Node<Item>(item);
        node.next = n;
        n.pre = node;
        first.next = node;
        node.pre = first;
        ++size;
    }

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

        Node<Item> node = new Node<Item>(item);
        node.pre = last.pre;
        node.next = last;
        last.pre.next = node;
        last.pre = node;
        ++size;

    }

    public Item removeFirst()                // remove and return the item from the front
    {
        if (size == 0)
            throw new java.util.NoSuchElementException();
        Node<Item> x = first.next;
        x.next.pre = first;
        first.next = x.next;

        --size;
        return x.item;

    }

    public Item removeLast()                 // remove and return the item from the end
    {
        if (size == 0)
            throw new java.util.NoSuchElementException();

        Node<Item> x = last.pre;
        last.pre = x.pre;
        x.pre.next = last;

        --size;
        return x.item;
    }

    public static void main(String[] args)   // unit testing (optional)
    {

    }
}

RandomizedQueue.java

import java.util.Iterator;

import edu.princeton.cs.algs4.StdRandom;

/**
 * Created by LK on 2017/4/4.
 */
public class RandomizedQueue<Item> implements Iterable<Item> {


    private int size;
    private Item[] data;

    private class RandomizedQueueIterator implements Iterator<Item> {

        private int[] index;
        private int current;

        public RandomizedQueueIterator() {
            index = new int[size];

            for (int i = 0; i < size; ++i)
                index[i] = i;


            StdRandom.shuffle(index);
            current = 0;

        }

        @Override
        public boolean hasNext() {
            return current < size;
        }

        @Override
        public Item next() {
            if (hasNext())
                return data[index[current++]];

            throw new java.util.NoSuchElementException();

        }

        @Override
        public void remove() {
            throw new java.lang.UnsupportedOperationException();
        }
    }

    public RandomizedQueue()                 // construct an empty randomized queue
    {
        data = (Item[]) new Object[1];
        this.size = 0;
    }

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

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

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

        if (size == data.length) {
            Item[] data2 = (Item[]) new Object[data.length * 2];
            for (int i = 0; i < size; i++) {
                data2[i] = data[i];
            }
            data = data2;
        }
        data[size] = item;
        ++size;
    }

    public Item dequeue()                    // remove and return a random item
    {
        if (this.size == 0)
            throw new java.util.NoSuchElementException();
        int x = StdRandom.uniform(size);
        Item item = data[x];
        if (x != size - 1) {
            data[x] = data[size - 1];
        }
        data[size - 1] = null;
        --size;


        return item;

    }

    public Item sample()                     // return (but do not remove) a random item
    {
        if (this.size == 0)
            throw new java.util.NoSuchElementException();

        int x = StdRandom.uniform(size);
        return data[x];
    }

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


    public static void main(String[] args) {

    }

}

Permutation.java

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

/**
 * Created by LK on 2017/4/4.
 */
public class Permutation {
    public static void main(String[] args) {
        int n = 0;
        if (args.length >= 1)
            n = Integer.parseInt(args[0]);
        RandomizedQueue<String> randomizedQueue = new RandomizedQueue<String>();
        while (!StdIn.isEmpty()) {
            String x = StdIn.readString();
            randomizedQueue.enqueue(x);
        }

        for (int i = 0; i < n; ++i)
            StdOut.println(randomizedQueue.dequeue());

    }
}

欢迎交流