程序员面试金典--题目解析-2.4 给定一个x，所有小于x的结点排在大于等于x结点之前

2.4 题目：

以给定值x为基准，将链表分隔为两部分。所有小于x的结点排在大于或等于x结点之前。

解法：

创建两个链表，before和after。依次遍历所给链表，小于x的插入到before之前，大于等于x的插入到after之前。

然后连接两个链表即可。

链表类：

1. public static class Node<E>{  
2.         private E item;  
3.         private Node<E> next;  
4.         private boolean isValid = true;  
5.           
6.           
7.           
8.         public boolean isValid() {  
9.             return isValid;  
10.         }  
11.         public Node(E item) {  
12.             this.item = item;  
13.         }  
14.         public E getItem() {  
15.             return item;  
16.         }  
17.         public void setItem(E item) {  
18.             this.item = item;  
19.         }  
20.         public Node<E> getNext() {  
21.             return next;  
22.         }  
23.         public void setNext(Node<E> next) {  
24.             this.next = next;  
25.         }  
26.         @Override  
27.         public String toString() {  
28.             return "Node [item=" + item + "]";  
29.         }  
30.           
31.           
32.           
33.     }  

分隔排序算法函数：

1. @SuppressWarnings("unchecked")  
2.     public static <T> Node<T> partition(Node<? extends Comparable<T>> node,T x){  
3.         Node beforeStart = null;  
4.         Node afterStart = null;  
5.           
6.         while(node != null){  
7.             Node next = node.next;  
8.             if(node.item == null){  
9.                 node = node.next;  
10.             }  
11.             else if(node.item.compareTo(x) < 0){  
12.                 node.next = beforeStart;  
13.                 beforeStart = node;  
14.             }  
15.             else{  
16.                 node.next = afterStart;  
17.                 afterStart = node;  
18.             }  
19.             node = next;  
20.         }  
21.           
22.         if(beforeStart == null)  
23.             return afterStart;  
24.           
25.         Node head = beforeStart;  
26.         while(beforeStart.next != null){  
27.             beforeStart = beforeStart.next;  
28.         }  
29.         beforeStart.next = afterStart;  
30.           
31.         return head;  
32.     }  

测试用例：

1. @Test  
2.     public void test_2_4(){  
3.         Node<Integer> head = new Node<>(0);  
4.         createIntegerNode(head, 20);  
5.         printNodeList(head);  
6.         System.out.println("---------------------");  
7.         head = LinkedListUtil.partition(head, 5);  
8.         printNodeList(head);  
9.     }  
10.       
11.     private Node<Integer> createIntegerNode(Node<Integer> head,int number){  
12.         Node<Integer> p = head;  
13.         for(int i = 1;i < number;i++){  
14.             if(i<(number/2)){  
15.                 p.setNext(new Node<Integer>(i));  
16.             }  
17.             else{  
18.                 p.setNext(new Node<Integer>(i%(number/2)));  
19.             }  
20.             p = p.getNext();  
21.         }  
22.         return head;  
23.     }  
24.       
25.     private <E> void printNodeList(Node<E> head){  
26.         Node<E> node = head;  
27.         while(node != null && node.isValid()){  
28.             System.out.println(node.getItem());  
29.             node = node.getNext();  
30.         }  
31.     }  

测试结果：

以5为分隔点，原始链表为：

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 

分隔处理后的链表为：

4 3 2 1 0 4 3 2 1 0 9 8 7 6 5 9 8 7 6 5