链表的排序

本次讨论单向链表的排序。本质上讲，链表的排序与数组的排序在算法上有很多相通的地方，但是由于单向链表只能向后访问的特殊性，那些要求随机访问的排序算法在链表的排序上并不能施展手脚，所以只能采用相邻比较的排序方法：冒泡法，而且只能从前向后冒泡。链表的另一个问题是由于长度不是已知的，所以终止条件只能通过节点是否为空进行判断，而每次的循环次数也是如此。下面是两种排序方法，一种求出长度再排序，另一种直接进行排序。

另一种排序要求是倒序。当然，我们可以修改count1（），使其不分青红皂白总是交换相邻节点，只是复杂度较高。另一种优美简练的算法就是下面的reverse方法。代码中添加了注释，应该能看明白。核心思想就是化整为零，每次把即将要倒序的节点指向已倒序完成的节点序列，然后指针右移，直至结束。

    // 计算链表长度
public int count() {
	Node2<T> temp = head;
	int count = 0;
	while (temp != null) {
		count++;
		temp = temp.next;
	}
	return count;
}

// 用于两节点数据交换
private void swap(Node2<T> Node21, Node2<T> Node2) {
	T temp = Node21.key;
	Node21.key = Node2.key;
	Node2.key = temp;
}

// 由链表长度控制循环判断条件
public void sort1() {
	int n = count();
	if (n > 1) {// 至少两个节点才能排序；
		for (int i = 0; i < n; i++) {
			Node2<T> temp = head;
			for (int j = 0; j < n - i - 1; j++) {// 相邻比较，前者小则互换值。（升序排列）
				if (((Person) temp.key).compareTo((Person) temp.next.key) == 1)
					swap(temp, temp.next);
				temp = temp.next;// 指针右移
			}
		}
	}
}

// 此处维护两个指针，index记录外层循环的起始位置，每次右移；temp和sort1（）方法里的temp指针作用一致，表示内层循环。
public void sort2() {
	Node2<T> index = head;
	while (index != null) {
		Node2<T> temp = index;
		while (temp != null && temp.next != null) {
			if (((Person) temp.key).compareTo((Person) temp.next.key) == -1)
				swap(temp, temp.next);
			temp = temp.next;
		}
                    // 注意此处，由于链表只能向右访问，导致最值只能冒向右侧。我们的外层循环指针之所以也是右移，是因为下面对头节点和尾节点进行了互换，使得最 值相当于冒向左侧。
		swap(index, temp);
		index = index.next;
	}
}

  //此处为链表的反转操作，逻辑存在一定难度，但已是我见过的精炼优美的代码
   public ListNode reverse(ListNode head) {
	ListNode  result = null;声明一个链表
	while(head != null){
		ListNode temp = head.next;（1）//因下一步要修改head.next，（1）将右移指针保存起来，（4）最后再给head；
		head.next = result;（2）//（2）就是把下一个等待倒序的节点（head）指向已经倒序完成的result节点，这样又有一个节点完成了倒序；
		result = head;（3）//（3）把结果重新指向最新的倒序节点序列；
		head = temp;（4）//指针右移；
	}
	return result;
}