考查排序算法时大多数情况下被排序数据都是数组形式，但也有可考查链表形式的排序算法。主要差异就是在获取元素上，数组可以在o(1)时间内得到某个下标的元素，而链表只能在o(1)时间内得到下一个节点（如果是双链表也可以得到上一个节点）。明确这一特点之后，就比较容易完成链表的排序算法了。下面以快排为例进行实现。
数组形式：
大部分情况下所写的快排，应该都比较熟了
package chapter2;
import structure.ListNode;
import java.util.LinkedList;
import java.util.List;
/**
* Created by ryder on 2017/6/27.
*
*/
public class P79_QuickSortThreeWayImpl {
//数组快排，时间o(nlogn)(最差n^2)，空间o(logn)(最差n)，递归造成的栈空间的使用，不稳定
public static void quickSort(int[] data){
if(data==null || data.length<=1) return;
quickSortCore(data,0,data.length-1);
}
public static void quickSortCore(int[] data,int start,int end){
if(end-start<=0)
return;
int index = quickSortPartition(data,start,end);
quickSortCore(data,start,index-1);
quickSortCore(data,index+1,end);
}
public static int quickSortPartition(int[] data,int start,int end){
//选择第一个值作为基准
int pivot = data[start];
int left = start,right = end;
while(left<right){
while(left<right && data[right]>=pivot) {
right--;
}
if(left<right)
data[left] = data[right];
while(left<right && data[left]<pivot) {
left++;
}
if(left<right)
data[right] = data[left];
}
data[left] = pivot;
return left;
}
public static void testQuickSort(){
int[] data = {1,5,4,2,3};
quickSort(data);
System.out.print("数组快速排序：\t");
for(int item: data){
System.out.print(item);
System.out.print('\t');
}
System.out.println();
}
}
List形式：
百度一下[快排 链表]，会发现相当一部分人是使用java.util.List实现的。我也就写了一下。但这个List无法获取下一个节点，而给出的关键方法是set，get，所以在实现上与数组几乎一致，获取值的地方改成get(index),赋值的改成set(index,value)即可。此外，如果测试时传入的是arrayList，依旧是数组快排啊；如果传入的是LinkedList，那么代码中的set，get时间复杂度都是o(n)，完成一次分区就要o(n^2)了，还叫什么快排呢。
package chapter2;
import structure.ListNode;
import java.util.LinkedList;
import java.util.List;
/**
* Created by ryder on 2017/6/27.
*
*/
public class P79_QuickSortThreeWayImpl {
//通过List完成快排
public static void quickSortList(List<Integer> data){
if(data==null || data.size()<2)
return;
quickSortListCore(data,0,data.size()-1);
}
public static void quickSortListCore(List<Integer> data,int start,int end){
if(start>=end)
return;
int index = quickSortListPartition(data,start,end);
quickSortListCore(data,start,index-1);
quickSortListCore(data,index+1,end);
}
public static int quickSortListPartition(List<Integer> data,int start,int end){
int pivot = data.get(start);
int left = start,right = end;
while(left<right){
while(left<right && data.get(right)>=pivot)
right--;
if(left<right)
data.set(left,data.get(right));
while(left<right && data.get(left)<pivot)
left++;
if(left<right)
data.set(right,data.get(left));
}
data.set(left,pivot);
return left;
}
public static void testQuickSortList(){
List<Integer> data = new LinkedList<>();
data.add(1);
data.add(5);
data.add(4);
data.add(2);
data.add(3);
quickSortList(data);
System.out.print("基于List快速排序:\t");
System.out.println(data);
}
}
自定义List：
在LeetCode上如果说用单链表实现某一算法，一般都是自定义的一个单链表节点，只能获取节点值value及下一节点next。
在这种纯粹的链表节点下，上述快排是无法达到时间复杂度o(nlogn)的，因为上述算法的分区函数是使用左右指针向中间扫描完成的，而链表获取上一个节点的时间复杂度是o(n),这样完成分区时间就要o(n^2)，肯定不能让人满意。
这是就需要修改分区函数。其实快排的分区函数除了左右指针还有另一种实现，使用两个左指针向右移动，一个用于扫描，另一个用于划分小于基准值的区域。而从左向右移动，这种任务链表是可以在o(1)的时间复杂度下完成的。
package structure;
/**
* Created by ryder on 2017/6/13.
* 单链表节点
*/
public class ListNode<T> {
public T val;
public ListNode<T> next;
public ListNode(T val){
this.val = val;
this.next = null;
}
@Override
public String toString() {
StringBuilder ret = new StringBuilder();
ret.append("[");
for(ListNode cur = this;;cur=cur.next){
if(cur==null){
ret.deleteCharAt(ret.lastIndexOf(" "));
ret.deleteCharAt(ret.lastIndexOf(","));
break;
}
ret.append(cur.val);
ret.append(", ");
}
ret.append("]");
return ret.toString();
}
}
package chapter2;
import structure.ListNode;
import java.util.LinkedList;
import java.util.List;
/**
* Created by ryder on 2017/6/27.
*
*/
public class P79_QuickSortThreeWayImpl {
//自定义链表快排
public static void quickSortList2(ListNode<Integer> data){
if(data==null || data.next==null)
return;
quickSortListCore2(data,null);
}
//从start到end排序，不包括end
public static void quickSortListCore2(ListNode<Integer> start,ListNode<Integer> end){
if(start==end || start.next==end)
return;
ListNode<Integer> index = quickSortList2Partition(start,end);
quickSortListCore2(start,index);
quickSortListCore2(index.next,end);
}
//两个左起指针向右移动，right从start+1到end（不包括end）向右扫描值,[start,left]存储小于povot的值
//最终left存储pivot，[start,left)小于pivot，（left+1，end）大于pivot
public static ListNode<Integer> quickSortList2Partition(ListNode<Integer> start,ListNode<Integer> end){
int pivot = start.val;
ListNode<Integer> left = start;
ListNode<Integer> right = start.next;
while(right!=end){
if(right.val>=pivot)
right = right.next;
else{
left.val = right.val;
left = left.next;
right.val = left.val;
right = right.next;
}
}
left.val = pivot;
return left;
}
public static void testQuickSortList2(){
ListNode<Integer> data = new ListNode<>(1);
data.next = new ListNode<>(5);
data.next.next= new ListNode<>(4);
data.next.next.next= new ListNode<>(2);
data.next.next.next.next= new ListNode<>(3);
quickSortList2(data);
System.out.print("自定义链表快速排序:\t");
System.out.println(data);
}
}
整体测试：
package chapter2;
import structure.ListNode;
import java.util.LinkedList;
import java.util.List;
/**
* Created by ryder on 2017/6/27.
*
*/
public class P79_QuickSortThreeWayImpl {
public static void main(String[] args){
testQuickSort();
testQuickSortList();
testQuickSortList2();
}
}
测试结果：
数组快速排序： 1 2 3 4 5
基于List快速排序: [1, 2, 3, 4, 5]
自定义链表快速排序: [1, 2, 3, 4, 5]
