【基础算法】常用内部排序算法总结--快速排序

先来说下面试中常问到的快速排序算法。快排算法属于交换排序算的一种，时间复杂度O(nlogn),空间复杂度O(logn)~O(n),是一种不稳定的排序算法。快排的核心思想是每次将枢纽值（一般选择第一个元素为枢纽值）移动到最终位置。然后对最终位置两边的子数组分别采用快速排序，直到子数组的长度为1时终止。
递归版本的快排代码如下：

public static voidquickSort(int[] list, int low, int high) {
	if (low >= high) return;
	int left = low, right = high;
	int temp = list[left];
	while (left < right) {
		while (left < right && list[right] > temp) {
			right--;
		}
		list[left] = list[right];
		while (left < right && list[left] < temp) {
			left++;
		}
		list[right] = list[left];
	}
	list[left] = temp;
	quickSort(list, low, left -1);
	quickSort(list,left + 1, high);
}

非递归版本的快排代码如下：

public static voidquickSort(int[] list) {
	if (list.length <= 0) return ;
	Stack<Integer> stack = new Stack<>();
	//左右指针入栈
	stack.push(0);
	stack.push(list.length - 1);

	while (!stack.isEmpty()) {
		int high = stack.pop();
		int low = stack.pop();
		int pivotIndex = patition(list, low, high);
		if (low < pivotIndex) {
			stack.push(low);
			stack.push(pivotIndex - 1);
		}
		if (high > pivotIndex) {
			stack.push(pivotIndex + 1);
			stack.push(high);
		}
	}
}
public stack int patition(int[] list, int low, int high) {
	if (list.length <= 0) {
		return -1;
	}
	if (low >= high) {
		return -1;
	}
	int l = low;
	int r = high;
	int temp = list[low];
	while (l < r) {
		while (l < r && list[r] > temp) {
			r--;
		}
		list[l] = list[r];
		while (l < r && list[l] < temp) {
			l++;
		}
		list[r] = list[l];
	}
	list[l] = temp;
	return l;

}