荷兰问题以及快速排序

荷兰问题（一）

【题目】
给定一个数组arr，和一个数num，请把小于等于num的数放在数组左边，大于num的数放在数组右边。
【要求】
额外空间复杂度O(1),时间复杂度O(N)

private void sort(int[] arr, int left, int right, int num){
	int less = left - 1;
	int more = right + 1;
	while(left < more){
		if (arr[left]<=num){
			swap(arr, ++less, left++);
		} else {
			swap(arr, --more, left);
		}
	}
}

private void swap(int[] arr, int i, int j){
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}

荷兰问题（二）

【题目】
给定一个数组arr，和一个数num，请把小于num的数放在数组左边，等于num的数放在数组的中间，大于num的数放在数组右边。
【要求】
额外空间复杂度O(1)，时间复杂度O(N)

private int[] sort(int[] arr, int left, int right, int num){
	int less = left - 1;
	int more = right + 1;
	while(left < more){
		if (arr[left]<num){
			swap(arr, ++less, left++);
		} else if(arr[left]>num) {
			swap(arr, --more, left);
		} else {
			left++;
		}
	}
	//返回等于某值的开始下标以及结束下标
	return new int[]{less+1,more-1};
}

private void swap(int[] arr, int i, int j){
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}

快速排序2.0

【题目】
把数组范围内的最后一个数作为划分值，然后把数组通过荷兰国旗问题分成三个部分。左侧<划分值，中间==划分值，右侧>划分值
时间复杂度是O(N^2)

private void quickSort(int[] arr){
	if (null == arr || arr.length < 2){
        return;
    }
    quickSort(arr, 0, arr.length-1);
}

private void quickSort(int[] arr, int left, int right){
	if (left < right){
        int[] partition = partition(arr, left, right);
        quickSort(arr, left, partition[0]-1);
        quickSort(arr, partition[1]+1, right);
    }
}

private int[] partition(int[] arr, int left, int right){
    int less = left - 1;
    int more = right;
    while (left < more){
        if (arr[left] < arr[right]){
            swap(arr, ++less, left++);
        } else if(arr[left] > arr[right]){
            swap(arr, --more, left);
        } else {
            left++;
        }
    }
    swap(arr, more, right);
    return new int[]{less+1, more};
}

private void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

快速排序3.0

与一不同的是，随机选择一个数作为划分值，然后把数组通过荷兰国旗问题分成三个部分,与上面代码一致，只是多了一个随机值，交换数据，时间复杂度是O(N*logN)

详细代码如下：

private void quickSort(int[] arr){
	if (null == arr || arr.length < 2){
        return;
    }
    quickSort(arr, 0, arr.length-1);
}

private void quickSort(int[] arr, int left, int right){
	if (left < right){
		int pos = left + (int)(Math.random()*(right-left+1));
        swap(arr,pos,right);
        int[] partition = partition(arr, left, right);
        quickSort(arr, left, partition[0]-1);
        quickSort(arr, partition[1]+1, right);
    }
}

private int[] partition(int[] arr, int left, int right){
    int less = left - 1;
    int more = right;
    while (left < more){
        if (arr[left] < arr[right]){
            swap(arr, ++less, left++);
        } else if(arr[left] > arr[right]){
            swap(arr, --more, left);
        } else {
            left++;
        }
    }
    swap(arr, more, right);
    return new int[]{less+1, more};
}

private void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

快排1.0 选择最后一个数字，其他数字与它作对比，小于等于的，放在左边，大于的放在右边, 然后将这个数字作为中间分隔数字，
左侧区域的数字按照同样的方式，选择最右侧数字，左侧区域其他数字依次与他作对比，小于等于的放在左边，大于的放在右侧，
右侧区域的同理，递归排序直至只有一个元素时，则排序完成

快排2.0 和1.0类似，不同的是，等于的区域放在中间
快排3.0，随机选择一个数字放在最后，做快排，每次都是随机选择一个数字作对比， 相比较前两种方式，复杂度比较低O(N*logN)

快排2.0，划分值越是靠近两侧，复杂度就越高，划分值越靠近中间，，复杂度越低。时间复杂度是O(N^2)
快排3.0，等概率随机选择一个数作为划分值，时间复杂度是O(N*logN)