死磕算法-荷兰国旗问题

问题引入

荷兰国旗问题引入

代码

public class NetherlandsFlag {
	
	//交换顺序
	public static int[] partition(int[] arr,int l ,int r,int p) {
		//左边区域是数组索引-1
		int less = l - 1;
		//右边区域是数组索引+1
		int more = r + 1;
		while(l < more) {
			if(arr[l] < p) {
				swap(arr,++less,l++);
			}else if(arr[l] > p) {
				swap(arr,--more,l);
			}else {
				l++;
			}
		}
		//等于区域的左边界和有边界
		return new int[] {less+1,more-1};
	}
	
	//交换
	public static void swap(int[] arr ,int i,int j) {
		int tmp = arr[i];
		arr[i]=arr[j];
		arr[j]=tmp;
	}
	
	    // 打印
		public static void printArray(int[] arr) {
			if (arr == null) {
				return;
			}
			for (int i = 0; i < arr.length; i++) {
				System.out.print(arr[i] + " ");
			}
			System.out.println();
		}
		
		
		// 随机生成代码
		public static int[] generateArray() {
			int[] arr = new int[10];
			for (int i = 0; i < arr.length; i++) {
				arr[i] = (int) (Math.random() * 10);
			}
			return arr;
		}
		
		
		public static void main(String[] args) {
			int[] test = generateArray();
			printArray(test);
			int[] res =partition(test, 0, test.length-1, 5);
		}
}

快速排序

快速排序默认数组的最后一个变量为划分变量，这样就不需要传入用于划分左右边界的变量，并且不断进行递归。

public static void quickSort(int[] arr, int l, int r) {
		if (l < r) {
			swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
			int[] p = partition(arr, l, r);
			//不断递归
			quickSort(arr, l, p[0] - 1);
			quickSort(arr, p[1] + 1, r);
		}
	}

	public static int[] partition(int[] arr, int l, int r) {
		int less = l - 1;
		//设定最后一个变量为more区
		int more = r;
		while (l < more) {
			if (arr[l] < arr[r]) {
				swap(arr, ++less, l++);
			} else if (arr[l] > arr[r]) {
				swap(arr, --more, l);
			} else {
				l++;
			}
		}
		//将划分元素(数组中的最后一个)和more区的第一个元素交换，也就是将划分元素调整到等于区
		swap(arr, more, r);
		//返回包含两个元素的数组，内容为相等区域的范围
		return new int[] { less + 1, more };
	}