算法（Algorithms）第4版 练习 链表类 1.3.19~1.3.29

package com.qiusongde.linkedlist;

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

public class LinkedList<Item> implements Iterable<Item> {

    private Node<Item> first;

    //Node should be public static in this class
    //When it comes to LinkedList, Node should be accessed outside
    public static class Node<E> {
        public E item;
        public Node<E> next;
    }
    /**
     * initialize LinkedList
     */
    public LinkedList() {
        first = null;
    }

    public LinkedList(Node<Item> first) {
        this.first = first;
    }

    /**
     * insert item at the beginning of the list
     * @param item the item to be inserted
     */
    public void insertAtBeginning(Item item) {

        Node<Item> oldfirst = first;

        first = new Node<Item>();
        first.item = item;
        first.next = oldfirst;

    }

    /**
     * remove the item at the beginning of the list
     * @return return the item at the beginning of the list
     * @throws NoSuchElementException if this Linked List is empty
     */
    public Item removeFromBeginning() {

        if(isEmpty())
            throw new NoSuchElementException("LinkedList is empty");

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

        return item;
    }

    //1.3.19
    /**
     * remove the last node in the linked list whose first node is first
     *
     * @return return the item of the last node
     * @throws NoSuchElementException if this Linked List is empty
     */
    public Item removeTheLast() {

        Node<Item> precurrent;
        Item item = null;

        precurrent = findPreLastNode();

        //has not found
        if(precurrent.next == null) {
            throw new NoSuchElementException("LinkedList is empty");
        }

        item = precurrent.next.item;
        //some implementation will add one empty node as head, and head.next = first
        //if so, it's not necessary to have if condition here
        if(precurrent.next == first)
            first = first.next;
        else
            precurrent.next = precurrent.next.next;

        return item;
    }

    /**
     * return the previous last node
     *
     * @return return the previous last node.
     * If the last node is the first node, the previous last node is a virtual one
     */
    private Node<Item> findPreLastNode() {

        Node<Item> precurrent = new Node<Item>();
        precurrent.next = first;

        //find the previous last node
        //precurrent.next is the same as current
        while(precurrent.next != null && precurrent.next.next != null) {
            precurrent = precurrent.next;
        }

        return precurrent;
    }

    //1.3.20
    /**
     * delete the kth element in a linked list, if it exists.
     *
     * @param k the kth element, it should larger than 1
     * @throws IllegalArgumentException if k < 1
     * @throws NoSuchElementException if the size of the list is less than k
     */
    public Item delete(int k) {

        if(k < 1)
            throw new IllegalArgumentException("k must larger than 1");

        Node<Item> precurrent = new Node<Item>();
        precurrent.next = first;
        Item item;

        while(precurrent.next != null && k > 1) {
            precurrent = precurrent.next;
            k--;
        }

        if(precurrent.next == null)
            throw new NoSuchElementException("LinkedList hasn't so many elements");

        item = precurrent.next.item;
        if(precurrent.next == first)
            first = precurrent.next.next;
        else
            precurrent.next = precurrent.next.next;

        return item;
    }

    //1.3.21
    /**
     * find if some node in the list has key as its item field
     *
     * @param list the linked list of T
     * @param key the T key
     *
     * @return {@code true} some node exists.
     *          {@code false} no node exist
     */
    public static <T> boolean find(LinkedList<T> list, T key) {

        for(T s : list) {
            if(s.equals(key))
                return true;
        }

        return false;
    }

    //1.3.24
    /**
     * remove the node following the node x
     * (and does nothing if the argument or the next field in the argument node is null)
     *
     * @param x the given node
     */
    public static <T> void removeAfter(Node<T> x) {

        if(x == null || x.next == null)
            return;

        Node<T> current = x.next;
        x.next = null;

        while(current != null) {
            Node<T> temp = current.next;
            current.next = null;
            current = temp;
        }

    }

    //1.3.25
    /**
     * insert the second node after the first on its list.
     * and does nothing if either argument is null.
     *
     * @param first the first node
     * @param second the second node to be inserted after the first
     */
    public static <T> void insertAfter(Node<T> first, Node<T> second) {

        if(first == null || second == null)
            return;

        second.next = first.next;
        first.next = second;

    }

    //1.3.26
    /**
     * remove all of the nodes in the list that have key as its item field
     *
     * @param list the linked list of T
     * @param key the T key
     *
     * @return void
     *
     */
    public static <T> void remove(LinkedList<T> list, T key) {
        Node<T> precurrent;
        precurrent = findPreNode(list, key);

        //remove all of the nodes
        while(precurrent.next != null) {

            if(precurrent.next == list.first)
                list.first = list.first.next;
            else
                precurrent.next = precurrent.next.next;

            precurrent = findPreNode(list, key);
        }

    }

    //1.3.26
    /**
     * find the node in the list whose item equals key
     *
     * @param key the T key
     *
     * @return return the previous node whose item equals key
     */
    private static <T> Node<T> findPreNode(LinkedList<T> list, T key) {
        Node<T> precurrent = new Node<T>();
        precurrent.next = list.first;

        while(precurrent.next != null && !precurrent.next.item.equals(key)) {
            precurrent = precurrent.next;
        }

        return precurrent;
    }

    //1.3.27
    /**
     * return the value of the maximum key in the list
     *
     * @param list the linked list of Integer
     *
     * @return return the maximum key in the list
     */
    public static int max(LinkedList<Integer> list) {

        if(list.first == null)
            return 0;

        int max = 0;
        for(int val : list) {
            if(val > max)
                max = val;
        }

        return max;
    }

    //1.3.28
    /**
     * return the value of the maximum key in the list by recursion
     *
     * @param list the linked list of Integer
     *
     * @return return the maximum key in the list
     */
    public static int maxByRecursion(LinkedList<Integer> list) {

        if(list.first == null)
            return 0;

        int first = list.first.item;//first item
        list.first = list.first.next;//remove first item in the list
        int max = maxByRecursion(list);//calculate the maximum value of the new list

        if(first > max)
            return first;
        else
            return max;
    }

    /**
     *
     * see if the list is empty
     *
     * @return true if the list is empty.
     * false if the list isn't empty
     */
    public boolean isEmpty() {
        return first == null;
    }

    @Override
    public String toString() {
        String s = "";

        Node<Item> temp = first;

        while(temp != null) {
            Item item = temp.item;
            s += item + " ";
            temp = temp.next;
        }

        return s;
    }

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

    private class ListIterator implements Iterator<Item> {

        private Node<Item> current = first;

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

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

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

            return item;
        }

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

    }

}