对链表排序

要开始找工作，又挨了顿骂，这事不爽，刷一个LeetCode开心一下。

对链表排序：https://oj.leetcode.com/problems/sort-list/

看到链表排序，第一反应无外乎就是希尔排序、基数排序和桶排序。想了想最好写的是基数排序，源码如下：

public class Main {

	public static void main(String[] args) {
		int[] data = { -84, 142, 41, -17, -71, 170, 186, 183, -21, -76, 76, 10,
				29, 81, 112, -39, -6, -43, 58, 41, 111, 33, 69, 97, -38, 82,
				-44, -7, 99, 135, 42, 150, 149, -21, -30, 164, 153, 92, 180,
				-61, 99, -81, 147, 109, 34, 98, 14, 178, 105, 5, 43, 46, 40,
				-37, 23, 16, 123, -53, 34, 192, -73, 94, 39, 96, 115, 88, -31,
				-96, 106, 131, 64, 189, -91, -34, -56, -22, 105, 104, 22, -31,
				-43, 90, 96, 65, -85, 184, 85, 90, 118, 152, -31, 161, 22, 104,
				-85, 160, 120, -31, 144, 115 };
		ListNode head = new ListNode(data[0]);
		ListNode now = head;
		for (int i = 1; i < data.length; ++i) {
			now.next = new ListNode(data[i]);
			now = now.next;
		}
		sortList(head);
	}

	static class ListNode {
		int val;
		ListNode next;

		ListNode(int x) {
			val = x;
			next = null;
		}
	}

	public static ListNode sortList(ListNode head) {
		// radix
		final int RADIX = 10;
		// positive numbers
		ListNode[] positiveHeads = new ListNode[RADIX];
		ListNode[] positiveTails = new ListNode[RADIX];
		// negative
		ListNode[] negativeHeads = new ListNode[RADIX];
		ListNode[] negativeTails = new ListNode[RADIX];
		// radix
		int offset = 1;
		// longest number
		boolean maxInitialed = false;
		int max = 0;
		// continue sort on next digit
		boolean goNext = true;
		while (goNext) {
			// reset for next radix digit
			ListNode now = head;
			positiveHeads = new ListNode[RADIX];
			positiveTails = new ListNode[RADIX];
			negativeHeads = new ListNode[RADIX];
			negativeTails = new ListNode[RADIX];
			// iterate list
			while (null != now) {
				// initialize longest value
				if (!maxInitialed) {
					if (Math.abs(now.val) > max) {
						max = Math.abs(now.val);
					}
				}
				// hash to a radix container
				int index = (now.val / offset) % RADIX;
				if (now.val >= 0) {
					// positive
					if (null == positiveHeads[index]) {
						positiveHeads[index] = now;
						positiveTails[index] = now;
					} else {
						positiveTails[index].next = now;
						positiveTails[index] = now;
					}

					now = now.next;
					positiveTails[index].next = null;
				} else {
					// negative
					index = -index;
					if (null == negativeHeads[index]) {
						negativeHeads[index] = now;
						negativeTails[index] = now;
					} else {
						negativeTails[index].next = now;
						negativeTails[index] = now;
					}

					now = now.next;
					negativeTails[index].next = null;
				}
			}
			// merge list
			head = null;
			ListNode tail = null;
			// negative should be merged from 9 to 0
			for (int i = RADIX - 1; i >= 0; --i) {
				if (null == negativeHeads[i]) {
					continue;
				}
				if (null == head) {
					head = negativeHeads[i];
				} else {
					tail.next = negativeHeads[i];
				}
				tail = negativeTails[i];
			}
			// positive merged from 0 to 9
			for (int i = 0; i < RADIX; ++i) {
				if (null == positiveHeads[i]) {
					continue;
				}
				if (null == head) {
					head = positiveHeads[i];
				} else {
					tail.next = positiveHeads[i];
				}
				tail = positiveTails[i];
			}
			// initialized after one iteration
			maxInitialed = true;
			// next digit
			offset *= RADIX;
			// if no more big number to sort
			goNext = offset < max;
		}
		return head;
	}
}