算法与数据结构进阶课第三节笔记

bfprt算法与蓄水池算法

蓄水池算法

例1：假设有一个源源吐出不同球的机器，只有装下10个球的袋子，每一个吐出的球，要么放入袋子，要么永远扔掉，如何做到机器吐出每一个球之后，所有吐出的球都等概率被放进袋子里？

     public static class RandomBox {
		private int[] bag;
		private int N;
		private int count;

		public RandomBox(int capacity) {
			bag = new int[capacity];
			N = capacity;
			count = 0;
		}

		private int rand(int max) {
			return (int) (Math.random() * max) + 1;
		}

		public void add(int num) {
			count++;
			if (count <= N) {
				bag[count - 1] = num;
			} else {
				if (rand(count) <= N) {
					bag[rand(N) - 1] = num;
				}
			}
		}

		public int[] choices() {
			int[] ans = new int[N];
			for (int i = 0; i < N; i++) {
				ans[i] = bag[i];
			}
			return ans;
		}

	}

第k个球到来的时候，以10/k的概率放入袋子，扔的时候10个里面随机选一个

例2：给定一个能概率的返回0-7的函数，怎么做能等概率的返回某个范围

首先将这个给定的函数，均分，奇数时最大的那个返回重roll，这样可以概率的返回0，1, 之后想要概率的返回（0，n）就看n用二进制k位能表示，等概率的roll k次，大于n就重新开始，这样就能得到等概率的(0,n),如果是（n,x），那么先求（0，x-n）之后加n，

例3：给定一个能以p概率返回0,1-p概率返回1的函数:，怎么等概率的返回(0,1)

按二进制位roll，每次roll两遍，00,11舍弃，01认为是0,10认为是1

bfprt算法

在无序数组中求第K小的数

1）改写快排的方法    随机选一个数进行划分，小等大，等的范围里有没有k，没有就砍掉一半继续选随机数划分，因为是随机选所以最终还是收敛于O(n)

        // 改写快排，时间复杂度O(N)
	public static int minKth2(int[] array, int k) {
		int[] arr = copyArray(array);
		return process2(arr, 0, arr.length - 1, k - 1);
	}

        public static int[] copyArray(int[] arr) {
		int[] ans = new int[arr.length];
		for (int i = 0; i != ans.length; i++) {
			ans[i] = arr[i];
		}
		return ans;
	}

	public static int process2(int[] arr, int L, int R, int index) {
		if (L == R) {
			return arr[L];
		}
		int pivot = arr[L + (int) (Math.random() * (R - L + 1))];
		int[] range = partition(arr, L, R, pivot);
		if (index >= range[0] && index <= range[1]) {
			return arr[index];
		} else if (index < range[0]) {
			return process2(arr, L, range[0] - 1, index);
		} else {
			return process2(arr, range[1] + 1, R, index);
		}
	}

	public static int[] partition(int[] arr, int L, int R, int pivot) {
		int less = L - 1;
		int more = R + 1;
		int cur = L;
		while (cur < more) {
			if (arr[cur] < pivot) {
				swap(arr, ++less, cur++);
			} else if (arr[cur] > pivot) {
				swap(arr, cur, --more);
			} else {
				cur++;
			}
		}
		return new int[] { less + 1, more - 1 };
	}

	public static void swap(int[] arr, int i1, int i2) {
		int tmp = arr[i1];
		arr[i1] = arr[i2];
		arr[i2] = tmp;
	}

2）bfprt算法

过程和上面的差不多，不一样的是怎么选随机数

将原本的数组分成5个数的n个组，计算出每个组的中位数，不足则取上中位数，组合成一个新的数组，重新找中位数，拿着这个数去划分

快排的时候不用这样选数，是因为不管选什么，都得进行两侧递归，没有必要去这样选

        // 利用bfprt算法，时间复杂度O(N)
	public static int minKth3(int[] array, int k) {
		int[] arr = copyArray(array);
		return bfprt(arr, 0, arr.length - 1, k - 1);
	}

	// arr[L..R] 如果排序的话，位于index位置的数是什么，返回
	public static int bfprt(int[] arr, int L, int R, int index) {
		if (L == R) {
			return arr[L];
		}
		// 选一个数作为划分值
		int pivot = medianOfMedians(arr, L, R);
		int[] range = partition(arr, L, R, pivot);
		if (index >= range[0] && index <= range[1]) {
			return arr[index];
		} else if (index < range[0]) {
			return bfprt(arr, L, range[0] - 1, index);
		} else {
			return bfprt(arr, range[1] + 1, R, index);
		}
	}

	/**
	 *  五个数一组
	 *  每个小组内部排序
	 *  每个小组中位数拎出来，组成marr
	 *  marr中的中位数返回
	 * @param arr
	 * @param L
	 * @param R
	 * @return
	 */
	public static int medianOfMedians(int[] arr, int L, int R) {
		int size = R - L + 1;
		int offset = size % 5 == 0 ? 0 : 1;
		int[] mArr = new int[size / 5 + offset];
		for (int team = 0; team < mArr.length; team++) {
			int teamFirst = L + team * 5;
			mArr[team] = getMedian(arr, teamFirst, Math.min(R, teamFirst + 4));
		}
		// mArr[0..mArr.length - 1] 如果排序的话，位于mArr.length / 2 位置的数是什么，返回
		return bfprt(mArr, 0, mArr.length - 1, mArr.length / 2);
	}

	public static int getMedian(int[] arr, int L, int R) {
		insertionSort(arr, L, R);
		return arr[(L + R) / 2];
	}

	public static void insertionSort(int[] arr, int L, int R) {
		for (int i = L + 1; i <= R; i++) {
			for (int j = i - 1; j >= L && arr[j] > arr[j + 1]; j--) {
				swap(arr, j, j + 1);
			}
		}
	}