单向链表的归并排序——java实现

在做Coursera上的Algorithms第三周测验练习的时候有一道链表随机排序问题，刚开始没有什么思路，就想着先把单向链表归并排序实现了，再此基础上进行随机排序的改造。于是就结合归并排序算法，实现了单向链表的归并排序。

import java.util.Iterator;
/**
 * 对单向链表的由小到大归并排序
 * @author evasean www.cnblogs.com/evasean/
 * @param <T>
 */
public class MergeSortLinkedList <T extends Comparable<T>> implements Iterable<T>{
    private Node first = null;
    private Node last = null;
    private int n;
    private class Node{
        T element;
        Node next;
    }
    private boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }
    @Override
    public Iterator<T> iterator() {
        // TODO Auto-generated method stub
        return new ListIterator();
    }
    private class ListIterator implements Iterator<T>{
        private Node current = first;
        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return current != null;
        }

        @Override
        public T next() {
            // TODO Auto-generated method stub
            T t = current.element;
            current = current.next;
            return t;
        }
    }
    public void add(T t){
        Node node = new Node();
        node.element = t;
        node.next = null;
        if(first == null && last == null){
            first = node;
            last = node;
        }else if(first != null && first == last){
            first.next = node;
            last = node;
        }else{
            last.next = node;
            last = node;
        }
        n++;
    }
    @Override
    public String toString(){
        Iterator<T> iter = iterator();
        String ret = iter.next().toString();
        while(iter.hasNext()){
            ret += ", "+ iter.next().toString() ;
        }
        return ret;    
    }
    public void mergeSort(){
        first = sort(first);
    }
    
    private Node sort(Node head){
        if(head == null || head.next == null) return head;
        Node slow = head;
        Node fast = head;
        //取中间节点
        while(fast.next != null && fast.next.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        Node left = head;
        Node right = slow.next;
        slow.next = null; //将左右链表分开
        left = sort(left);
        right = sort(right);
        return merge(left,right);
    }
    private Node merge(Node left, Node right){
        //System.out.println("left="+left.element+",right="+right.element);
        Node aux = new Node(); //需要耗费logn的额外空间
        Node l= left;
        Node r = right;
        Node current = aux;
        while(l != null && r!=null){
            if(less(r.element,l.element)) {
                current.next = r;
                current = current.next;
                r = r.next;
            }
            else {
                current.next = l;
                current = current.next;
                l= l.next;
            }
        }
        if(l!=null) current.next = l; // 如果左侧没遍历完，将其连接至current后
        else if(r != null) current.next = r; //如果右侧没遍历完，将其连接至current后
        return aux.next; //返回归并好的链表
    }
     public static void main(String[] args){
         ShuffleLinkedList<Integer> sll = new ShuffleLinkedList<Integer>();
         sll.add(1);
         sll.add(2);
         sll.add(11);
         sll.add(9);
         sll.add(10);
         sll.add(4);
         sll.add(7);
         System.out.println(sll);
         sll.mergeSort();
         System.out.println(sll);
     }

}