Coursera Algorithms week3 归并排序 练习测验: Shuffling a linked list

题目原文：

Shuffling a linked list. Given a singly-linked list containing n items, rearrange the items uniformly at random. Your algorithm should consume a logarithmic (or constant) amount of extra memory and run in time proportional to nlogn in the worst case.

分析：

此题要求对单向链表进行随机排序，可以考虑先实现个链表的归并排序(见我的另一篇文章)，再改造成这里的随机排序。

import java.util.Iterator;
import edu.princeton.cs.algs4.StdRandom;
/**
 /**
 * 对单向链表的随机归并排序
 * @author evasean www.cnblogs.com/evasean/
 * @param <T>
 */
public class ShuffleLinkedList<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){
            int rand = StdRandom.uniform(2);
            if(rand == 0){ //如果随机数选为0，则从左侧选取元素
                current.next = l;
                current = current.next;
                l= l.next;
            }else{ //如果随机数选为1，则从右侧选取元素
                current.next = r;
                current = current.next;
                r = r.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);
     }

}