算法Sedgewick第四版-第1章基础-016一list

 

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

public class List<Item> implements Iterable<Item>
{
    private int N;
    private Node first;
    private Node last;

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

    public List()
    {
        first = null;
        last  = null;
    }
    
    public List(Item[] a)
    {
        for (Item t : a)
            append(t);
    }

    public List(Iterable<Item> coll)
    {
        for (Item t : coll)
            append(t);
    }

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

    public int size()
    {
        return N;     
    }
    
    public Item first()
    {
        if (isEmpty()) throw new RuntimeException("List is empty");
        return first.item;
    }
    
    public Item last()
    {
        if (isEmpty()) throw new RuntimeException("List is empty");
        return last.item;
    }
    
    public Item removeFirst()
    {
        if (isEmpty()) throw new RuntimeException("List is empty");
        Item item = first.item;
        first = first.next;
        N--;
        if (isEmpty()) last = null;   // to avoid loitering
        return item;
    }
    
    public void prepend(Item item)
    {
        Node x = new Node();
        x.item = item;
        if (isEmpty()) { first = x;      last = x;  }
        else           { x.next = first; first = x; }
        N++;
    }

    public void append(Item item)
    {
        Node x = new Node();
        x.item = item;
        if (isEmpty()) { first = x;     last = x; }
        else           { last.next = x; last = x; }
        N++;
    }
    
    public String toString()
    {
        StringBuilder s = new StringBuilder();
        for (Item item : this)
            s.append(item + " ");
        return s.toString();
    } 
 
    public Iterator<Item> iterator()
    {
        return new ListIterator();  
    }

    private class ListIterator 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;
        }
    }
    
    /*****************
     * Exercise 1.3.19
     *****************/
    public Item removeLast()
    {
        if (isEmpty()) throw new RuntimeException("List is empty");
        if (first == last) return removeFirst();
        Item item = last.item;
        
        Node prev = null,
             curr = first;
        while (curr.next != null)
        {
            prev = curr;
            curr = curr.next;
        }
        prev.next = null;
        last = prev;
        N--;
        
        return item;
    }
    
    /*****************
     * Exercise 1.3.20
     *****************/
    public Item delete(int k)
    {
        if (k < 1) return null;
        
        int i = 1;
        Node prev = null,
             curr = first;
        
        while (i < k && curr != null)
        {
            prev = curr;
            curr = curr.next;
            i++;
        }
        
        if (curr != null)
        {
            if (prev == null)
                first = curr.next;
            else
                prev.next = curr.next;
            
            if (curr.next == null)
                last = prev;
            
            N--;
            return curr.item;
        }
        else
            return null;
    }
    
    /*************************************
     * Exercise 1.3.21
     * (Renamed from find() to contains())
     *************************************/
    public boolean contains(Item item)
    {
        Node curr = first;
        while (curr != null && !curr.item.equals(item))
            curr = curr.next;
        return curr != null;
    }
    
    /*****************
     * Exercise 1.3.26
     *****************/
    public void remove(Item item)
    {
        List<Integer> idx = new List<Integer>();
        int i = 1;
        
        for (Item x : this)
        {
            if (x.equals(item))
                idx.prepend(i);
            i++;
        }
        
        for (int k : idx)
            delete(k);
    }
    
    /***************************************
     * Recursive solution to Exercise 1.3.26
     ***************************************/
    public void removeRec(Item item)
    {
        first = remove_Node(first, item);
        setLastAndN();
    }
    
    private Node remove_Node(Node node, Item item)
    {
        if (node != null)
        {
            Node rest = remove_Node(node.next, item);
            
            if (node.item.equals(item))
                return rest;
            else
            {
                node.next = rest;
                return node;
            }
        }
        else
            return null;
    }
    
    private void setLastAndN()
    {
        last = first;
        N = 0;
        if (first != null)
        {
            N++;
            while (last.next != null)
            {
                last = last.next;
                N++;
            }
        }
    }
    
    
    /*********************
     * Operations on nodes
     *********************/
    
    public Node node(int k)
    {
        if (k < 1) return null;
        
        int i = 1;
        Node curr = first;
        
        while (i < k && curr != null)
        {
            curr = curr.next;
            i++;
        }
        
        return curr;
    }
    
    public Node createNode(Item item)
    {
        Node node = new Node();
        node.item = item;
        return node;
    }
    
    /*****************
     * Exercise 1.3.24
     *****************/
    public void removeAfter(Node node)
    {
        if (node != null && node.next != null)
        {
            if (node.next.next == null)
                last = node;
            node.next = node.next.next;
            N--;
        }
    }
    
    /*****************
     * Exercise 1.3.25
     *****************/
    public void insertAfter(Node a, Node b)
    {
        if (a != null && b != null)
        {
            if (last == a)
                last = b;
            b.next = a.next;
            a.next = b;
            N++;
        }
    }
    
    /*************************************************
     * Exercise 1.3.27
     * Type 'Item' must implement interface Comparable
     *************************************************/
    public Item max(Node node)
    {
        if (node == null) throw new RuntimeException("List is empty");
        return max(node, null);
    }
    
    public Item max(Node node, Item def)
    {
        if (node == null)
            return def;
        
        Item max = node.item;
        Node curr = node;
        
        while (curr.next != null)
        {
            curr = curr.next;
            if (((Comparable)max).compareTo(curr.item) < 0)
                max = curr.item;
        }
        
        return max;
    }
    
    /*************************************************
     * Exercise 1.3.28
     * (recursive variant of Exercise 1.3.27)
     * Type 'Item' must implement interface Comparable
     *************************************************/
    public Item maxRec(Node node, Item def)
    {
        if (node == null)
            return def;
        else
            return maxRec(node);
    }
    
    public Item maxRec(Node node)
    {
        if (node == null) throw new RuntimeException("List is empty");
        
        if (node.next == null)
            return node.item;
        else
        {
            Item maxTail = maxRec(node.next);
            return ((Comparable)node.item).compareTo(maxTail) > 0 ? node.item : maxTail;
        }
    }
    
    /*****************
     * Exercise 1.3.30
     *****************/
    public void reverse()
    {
        first = reverse(first);
        setLastAndN();
    }
    
    public Node reverse(Node node)
    {
        Node srcFirst = node,
             destFirst = null;
        while (srcFirst != null)
        {
            Node next = srcFirst.next;
            srcFirst.next = destFirst;
            destFirst = srcFirst;
            srcFirst = next;
        }
        
        return destFirst;
    }
    
    /***************************************
     * Recursive solution to Exercise 1.3.30
     ***************************************/
    public void reverseRec()
    {
        first = reverseRec(first);
        setLastAndN();
    }
    
    private Node reverseRec(Node node)
    {
        return reverseRec(node, null);
    }
    
    private Node reverseRec(Node srcFirst, Node destFirst)
    {
        if (srcFirst == null)
            return destFirst;
        else
        {
            Node next = srcFirst.next;
            srcFirst.next = destFirst;
            return reverseRec(next, srcFirst);
        }
    }
        
    
    /************
     * Unit tests
     ************/
    
    private static void testBaseMethods()
    {
        int[] a = { 2, 4, 6, 8, 10, 12 };
        
        List<Integer> lst = new List<Integer>();
        for (int i = 0; i < a.length; i++)
            lst.append(a[i]);
        showList(lst);
        
        lst = new List<Integer>();
        for (int i = 0; i < a.length; i++)
            lst.prepend(a[i]);
        showList(lst);
        
        StdOut.println("removeFirst: " + lst.removeFirst());
        showList(lst);
    }
    
    private static void testRemoveLast()
    {
        List<Integer> lst = new List<Integer>(new Integer[] { 6, 8, 10, 12 });
        showList(lst);
        
        while (!lst.isEmpty())
        {
            StdOut.println("removeLast: " + lst.removeLast());
            showList(lst);
        }
    }
    
    private static void testDelete()
    {
        List<Integer> lst = new List<Integer>(new Integer[] { 2, 4, 6, 8, 10, 12 });
        showList(lst);
        
        StdOut.printf("delete(%d): %s\n", 5, lst.delete(5));
        showList(lst);
        
        StdOut.printf("delete(%d): %s\n", 1, lst.delete(1));
        showList(lst);
        
        StdOut.printf("delete(%d): %s\n", 4, lst.delete(4));
        showList(lst);
        
        StdOut.printf("delete(%d): %s\n", 8, lst.delete(8));
        showList(lst);
        
        StdOut.printf("delete(%d): %s\n", 0, lst.delete(0));
        showList(lst);
        
        while (!lst.isEmpty())
        {
            StdOut.printf("delete(%d): %s\n", 1, lst.delete(1));
            showList(lst);
        }
    }
    
    private static void testContains()
    {
        Integer[] a = { 4, 6, 10, 12 };
        List<Integer> lst = new List<Integer>(a);
        showList(lst);
        
        StdOut.printf("contains(%d): %s\n", 0, lst.contains(0));
        
        for (int i = 0; i < a.length; i++)
            StdOut.printf("contains(%d): %s\n", a[i], lst.contains(a[i]));
    }
    
    private static void testRemove()
    {
        for (int k = 0; k < 8; k++)
        {
            List<Integer> lst1 = randomList(20, 0, 5);
            List<Integer> lst2 = new List<Integer>(lst1);
            StdOut.println(lst1);
            StdOut.println();
            
            int n = StdRandom.uniform(0, 5);
            
            StdOut.printf("remove(%d):\n", n);
            lst1.remove(n);
            showList(lst1);
            
            StdOut.printf("removeRec(%d):\n", n);
            lst2.removeRec(n);
            showList(lst2);
            StdOut.println();
        }
    }
    
    private static void testReverse()
    {
        int n = 10;
        Integer[] a = new Integer[n];
        for (int i = 0; i < n; i++)
            a[i] = 2 * (i + 1);
        
        testReverse(new List<Integer>(a));
        StdOut.println();
        
        testReverse(randomList(20, 0, 10));
        StdOut.println();
        
        testReverse(new List<Integer>(new Integer[] { 37 }));
        StdOut.println();
        
        testReverse(new List<Integer>(new Integer[] { }));
        StdOut.println();
    }
    
    private static void testReverse(List<Integer> lst)
    {
        List<Integer> lst1 = lst;
        List<Integer> lst2 = new List<Integer>(lst1);
        StdOut.println(lst1);
        
        StdOut.println("reverse():");
        lst1.reverse();
        StdOut.println(lst1);
        
        StdOut.println("reverseRec():");
        lst2.reverseRec();
        StdOut.println(lst2);
    }
    
    private static void testNode()
    {
        List<Integer> lst = new List<Integer>(new Integer[] { 2, 6, 12 });
        showList(lst);
        
        for (int i = -1; i <= 4; i++)
            StdOut.printf("node(%d): %s\n", i, lst.node(i) != null ? lst.node(i).item : null);
    }
    
    private static void testRemoveAfter()
    {
        List<Integer> lst = new List<Integer>(new Integer[] { 2, 6, 8, 10, 12 });
        showList(lst);
        
        int[] k = { 0, 2, 1, 5, 3, 2, 1 };
        
        for (int i = 0; i < k.length; i++)
        {
            StdOut.printf("removeAfter(node(%d)):\n", k[i]);
            lst.removeAfter(lst.node(k[i]));
            showList(lst);
        }
    }
    
    private static void testInsertAfter()
    {
        List<Integer> lst = new List<Integer>(new Integer[] { 2, 6, 10, 12 });
        showList(lst);
        
        StdOut.printf("insertAfter(node(%d), null):\n", 1);
        lst.insertAfter(lst.node(1), null);
        showList(lst);
        
        int ia = 1,
            b = 3;
        StdOut.printf("insertAfter(node(%d), createNode(%d)):\n", ia, b);
        lst.insertAfter(lst.node(ia), lst.createNode(b));
        showList(lst);
        
        ia = 5;
        b = 25;
        StdOut.printf("insertAfter(node(%d), createNode(%d)):\n", ia, b);
        lst.insertAfter(lst.node(ia), lst.createNode(b));
        showList(lst);
    }
    
    private static void testMax()
    {
        for (int k = 0; k < 8; k++)
        {
            List<Integer> lst = randomList(10, 100, 1000);
            StdOut.println(lst);
            
            StdOut.printf("max():    %d\n", lst.max(lst.node(1)));
            StdOut.printf("maxRec(): %d\n\n", lst.maxRec(lst.node(1)));
        }
    }
    
    
    /*******************
     * Unit test helpers
     *******************/
    
    public static void showList(List lst)
    {
        StdOut.println(lst);
        if (!lst.isEmpty())
            StdOut.printf("Size: %d, First: %s, Last: %s\n\n", lst.size(), lst.first(), lst.last());
        else
            StdOut.printf("Size: %d\n\n", lst.size());
    }
    
    private static List<Integer> randomList(int n, int a, int b)
    {
        Integer[] r = new Integer[n];
        for (int i = 0; i < n; i++)
            r[i] = StdRandom.uniform(a, b);
        return new List<Integer>(r);
    }
    
    public static void main(String[] args)
    {
        testBaseMethods();
        StdOut.println();
        
        testRemoveLast();
        StdOut.println();
        
        testDelete();
        StdOut.println();
        
        testContains();
        StdOut.println();
        
        testNode();
        StdOut.println();
        
        testRemoveAfter();
        StdOut.println();
        
        testInsertAfter();
        StdOut.println();
        
        testRemove();
        StdOut.println();
        
        testMax();
        StdOut.println();
        
        testReverse();
        StdOut.println();
    }
}