快速排序原理:快排采集分治法的思想,根据排序基准值把待数据分成两份,左边的数据比基准值小,右边的数据比基准值大,然后左右两边数据再按照各自己基准值划分...直至分解已排序的小数组,最终得到已排序数组。
关于基准值位置查找
微缩:最左边的设为基准值,从后往前找小的,找到移到前面,再从前往后找大的,再找到移到后面...直到找不到为止。
啰嗦:把最前面的数值当做基准值,然后从数组的右边位置向左找比基准值小的数据,没找到说明最前面的位置就是基准值位置;找到就移到最前面,然后从前面位置开始往后找比基准值大的数据,没找到说明前一个比基准值小的数据的原始位置就是基准值位置,把基准值放入该位置;找到则从后往前找小...直到前面和后面的位置相遇,查找结束,把基准值放入相遇位置。
时间复杂度:最优O(nlogn),最坏O(n^2),平均O(nlogn)
最优情况在每次查找的基准值位置恰好把数组二等分;
最坏情况是数组已经排好序,无论是升序还是降序;
下面是快排的递归和非递归两种实现版本,当排序数量小于插入排序的阈值时,改用插入排序
public static final int INSERTIONSORT_THRESHOLD = 7;
public static <T extends Comparable<T>> int compare(T a, T b) {
if (a == null){
return b == null ? 0 : -1;
}
if (b == null){
return 1;
}
return a.compareTo(b);
}
/**
* @description 查找基准值
* @param data
* @param offset
* @param end
* @return
*/
public static <T extends Comparable<T>> int findIndex(T[] data, int offset, int end) {
T tmp = data[offset];
while (offset < end) {
while (compare(tmp, data[--end]) < 0);// 从后往前找小的
if (offset < end) {
data[offset] = data[end];// 小的往前移
while (++offset < end && compare(tmp, data[offset]) >= 0);// 从前往后找大的
if (offset < end){
data[end] = data[offset];// 大的往后移
}
}
}
data[offset] = tmp;
return offset;
}
递归快排
/**
* @description 快排递归算法
* @param data
* @param offset
* @param end
*/
public static <T extends Comparable<T>> void quickSortRecursion(T[] data, int offset, int end) {
if (end - offset < INSERTIONSORT_THRESHOLD) {
insertSort(data, offset, end);
return;
}
int i = findIndex(data, offset, end);
if (i - 1 > offset){
quickSortRecursion(data, offset, i);
}
if (++i < end){
quickSortRecursion(data, i, end);
}
}
使用自定义栈模拟方法栈来实现非递归快排
/**
* @description 快排非递归算法
* @param stack 实例空栈
* @param data 待排数组
* @param offset 开始位置
* @param end 结束位置
*/
public static <T extends Comparable<T>> void quickSort(Stack stack, T[] data, int offset, int end) {
stack.push(end);
stack.push(offset);
int i;
while (!stack.empty()) {
offset = stack.pop();
end = stack.pop();
i = findIndex(data, offset, end);
if (i + 1 + INSERTIONSORT_THRESHOLD <= end) {
stack.push(end);
stack.push(i + 1);
} else {
insertSort(data, i + 1, end);
}
if (offset + INSERTIONSORT_THRESHOLD <= i) {
stack.push(i);
stack.push(offset);
} else {
insertSort(data, offset, i);
}
}
}
链栈和数组栈的实现
/**
* @description 栈接口
* @author Luckywb
* @version 1.0 2013-07-13
*/
public interface Stack{
public void push(int value);
public boolean empty();
public int peek();
public int pop();
}
/**
* @description 链栈
* @author Luckywb
* @version 1.0 2013-07-13
*/
public class LinkedStack implements Stack {
private Node node;
private int value;
public void push(int value) {
node = new Node(node, this.value);
this.value = value;
}
public boolean empty() {
return node == null;
}
public int peek() {
return value;
}
public int pop() {
final int tmp = this.value;
this.value = node.value();
this.node = node.next;
return tmp;
}
public String toString() {
StringBuilder sb = new StringBuilder(value);
Node st = this.node;
while (st != null) {
sb.append("->").append(st.value());
st = st.next;
}
return sb.toString();
}
public static class Node {
private int value;
protected Node next;
public Node(int value) {
this.value = value;
}
public Node(Node next, int value) {
this.next = next;
this.value = value;
}
public void add(int value) {
Node tmp = this;
while (tmp.next != null) {
tmp = tmp.next;
}
tmp.next = new Node(value);
}
public Node remove() {
final Node tmp = next;
next = null;
return tmp;
}
public int value() {
return value;
}
}
}
/**
* @description 数组栈
* @author Luckywb
* @version 1.0 2013-07-13
*/
public class ArrayStack implements Stack {
int[] value;
int top;
public ArrayStack(int len) {
top = -1;
value = new int[len];
}
public void ensureCapacity() {
int len = value.length;
if (top + 1 == len) {
int[] dest = new int[len << 1];
System.arraycopy(value, 0, dest, 0, len);
value = dest;
}
}
public void push(int val) {
ensureCapacity();
value[++top] = val;
}
public boolean empty() {
return top < 0;
}
public int pop() {
return value[top--];
}
public int peek() {
return value[top];
}
}