快速排序

快速排序原理：快排采集分治法的思想，根据排序基准值把待数据分成两份，左边的数据比基准值小，右边的数据比基准值大，然后左右两边数据再按照各自己基准值划分...直至分解已排序的小数组，最终得到已排序数组。

 

关于基准值位置查找

微缩：最左边的设为基准值，从后往前找小的，找到移到前面，再从前往后找大的，再找到移到后面...直到找不到为止。

啰嗦：把最前面的数值当做基准值，然后从数组的右边位置向左找比基准值小的数据，没找到说明最前面的位置就是基准值位置；找到就移到最前面，然后从前面位置开始往后找比基准值大的数据，没找到说明前一个比基准值小的数据的原始位置就是基准值位置，把基准值放入该位置；找到则从后往前找小...直到前面和后面的位置相遇，查找结束，把基准值放入相遇位置。

 

时间复杂度：最优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];
	}

}