java代码快速排序

 

 

1.最简洁版（源自算法导论）

     /**
     * @param a 数组数据
     * @param l 左边界
     * @param r 右边界
     */
    public void quickSort(int[] a, int l, int r) {
        if (l >= r) return;//过滤边界
        int dp = l;//分界点位置（divide point）
        for (int i = l; i < r; i++) {
            if (a[i] < a[r]) { // 以最右的数为基准数pivot
                swap(a, i, dp++);// 所有分界点左边的数都应小于pivoit，如果不小于则放最左边并让分界点向前挪一个
            }
        }
        swap(a, r, dp);// 基准数归位
        quickSort(a, l, dp - 1);
        quickSort(a, dp + 1, r);
    }

    private void swap(int[] a, int s1, int s2) {
        if (s1 == s2) return;
        int temp = a[s1];
        a[s1] = a[s2];
        a[s2] = temp;
    }

 

2。随机优化版

 

public void random_quicksort(int[] a, int left, int right) {
		if (left >= right) { // 先判断边界，要排序的数组长度最少为2
			return;
		}
		// 在排序前，先随机换一下基准值，基准值位置默认为最右边
		Random r = new Random();
		int index = (r.nextInt(right - left)) + left;
		swap(a, index, right);

		int i = left; // 左指针，所指元素 都是已经确定好比基准值小。极端情况基准值选了个最小值，也会与第一个值交换
		int pivot = a[right];// 以最右边的值为基准值
		// 遍历，将比基准值小的数都一次放最左边
		for (int j = left; j < right; j++) {
			if (pivot > a[j]) {
				swap(a, i++, j); // i++ 移动指针
			}
		}
		swap(a, i, right); // 遍历完成后，则确认好了基准值的位置为i，让基准值归位
		quickSort1(a, left, i - 1); // 递归，分治
		quickSort1(a, i + 1, right);
	}
	
	private void swap(int[] a, int i, int j) {  //交换函数
		int temp;
		temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}

 

 

 

3.高效率版（源自快排发明者C.R.Hoare）

 

/**
 * @param a
 *            需要排序的目标数组
 * @param left
 *            左边界
 * @param right
 *            右边界
 */
public void quickSort2(int[] a, int left, int right) {
	// 先判断边界，要排序的数组长度最少为2
	if (left >= right) {
		return;
	}
	// 以左边第一个数为基准值
	int pivot = a[left];
	// 创建左右两个指针
	int i = left, j = right;
	// 跳出循环时i=j，说明找到基准数的位置
	while (i < j) {
		// 因为基准值确定为左边第一个位置，所以要先从右边向左边找比基准值小的数，跳出循环有两种情况，1 ：找到了这个数，2： i=j
		while (a[j] >= pivot && i < j) {
			j--;
		}
		// 再从左边找
		while (a[i] <= pivot && i < j) {
			i++;
		}
		if (i < j) {
			// 交换位置
			swap(a, i, j);
		}
	}
	// 跳出循环说明i=j,指针碰到一起，也就确定好了基准值的位置，让基准值归位
	swap(a, i, left);
	// 递归调用，分治
	quickSort2(a, left, i - 1);
	quickSort2(a, i + 1, right);
}
public void swap(int[] a,int i,int j){
    a[i]=a[i]+a[j];
    a[j]=a[i]-a[j];
    a[i]=a[i]-a[j];
}

/***********不用交换函数实现,但是原理一样*****************/
public void quickSort4(int[] a,int left,int right){
	if(left>=right){
		return;
	}
	int i=left,j=right;
	int pivot=a[left];
	while(i=pivot&&i=pivot&&i