How to find the max/min element of linked list

Question

I have a doubly linked list in my case. And I want to find the max and min element. So I want to use the Collections to find it. Here is my code below for Node first:

public class Node<T> {
    Node<T> prev;
    Node<T> next;
    T data;

    public Node(T _data)
    {
        data = _data;
        prev = null;
        next = null;
    }

    public Node(T _data, Node<T> _prev, Node<T> _next)
    {
        data = _data;
        prev = _prev;
        next = _next;
    }

    T getData()
    {
        return data;
    }

    public void setNext(Node<T> _next)
    {
        next = _next;
    }

    public void setPrev(Node<T> _prev)
    {
        prev = _prev;
    }

    public Node<T> getNext()
    {
        return next;
    }

    public Node<T> getPrev()
    {
        return prev;
    }
}

And here is my Doubly Linked List class:

public class DoublyLinkedList<T> {
    private Node<T> head;
    private Node<T> tail;
    int listCount = 0;

    public void traverseF()
    {
        Node<T> temp = head;

        while(temp != null)
        {
            System.out.print(temp.getData() + " ");
            temp = temp.getNext();
        }
    }

    public void traverseB()
    {
        Node<T> temp = tail;

        while(temp != null)
        {
            System.out.print(temp.getData() + " ");
            temp = temp.getPrev();
        }
    }

    public void insertFirst(T data)
    {
        Node<T> temp = new Node<T>(data);
        if(head == null)
        {
            head = temp;
            tail = temp;
            temp.setNext(null);
            temp.setPrev(null);
        }
        else
        {
            temp.setNext(head);
            head.setPrev(temp);
            head = temp;
        }
    }

}

So, my main code is:

import java.util.Collections;


public class glavna {

    public static void main(String[] args) {
        DoublyLinkedList<Integer> DLL = new DoublyLinkedList<Integer>();

        DLL.insertFirst(32);
        DLL.insertFirst(22);
        DLL.insertFirst(55);
        DLL.insertFirst(10);

        DLL.traverseF();

        Integer max = Collections.max(DLL);

    }
}

How exactly do I call the Collections.max or Collections.min method? Isn't the list only necessary to find the max/min elements?

public T getMin()
{
    Node<T> temp = head;
    T min = head.getData();
    while(temp.getNext() != null)
    {
        if(temp.getData() < min) // error
        {
            //min = temp.getData();
        }
    }
}

Answer 1

To implement getMin with generics you need to be able to compare them. You can, for instance, provide a custom Comparator to your method:

public T getMin(Comparator<? super T> comparator) {
    Node<T> temp = head.getNext();
    T min = head.getData();
    while(temp != null) {
        T candidateValue = temp.getData();
        if (comparator.compare(candidateValue, min) < 0) { // equivalent to candidate < min
            min = candidateValue;
        }
        temp = temp.getNext();
    }
    return min;
}

Then, calling your method for Integer :

getMin(new Comparator<Integer>() {
    @Override
    public int compare(Integer arg0, Integer arg1) {
        return arg0.compareTo(arg1);
    }
 });

Another approach is to make your list only keep Comparable items :

public class DoublyLinkedList<T extends Comparable<? super T>> {

and then have your getMin() method use compareTo method :

public T getMin() {
    Node<T> temp = head.getNext();
    T min = head.getData();
    while(temp != null) {
        T candidateValue = temp.getData();
        if (candidateValue.compareTo(min) < 0) { // equivalent to candidate < min
            min = candidateValue;
        }
        temp = temp.getNext();
    }
    return min;
}

Second approach is less verbose, as Integer is Comparable (ie implements Comparable for you already), so you won't need to change any other code.

Answer 2

您列出的不是集合，因此您无法将其与集合一起使用。

Answer 3

The Collections.max method expects an argument which implements Collection . The easiest way would probably be to extend AbstractCollection and add these methods:

@Override
public Iterator<T> iterator() {
    return new Iterator<T>() {
        private Node<T> node = head;
        @Override
        public boolean hasNext() {
            return node != null;
        }

        @Override
        public T next() {
            T next = node.data;
            node = node.getNext();
            return next;
        }
    };
}

@Override
public int size() {
    int size = 0;
    Node<T> node = head;
    while (node != null) {
        size++;
        node = node.getNext();
    }
    return size;
}