算法练习：随时找到数据流的中位数、微软折纸问题

随时找到数据流的中位数

实现思路

准备两个堆，一个放前 n/2 个数，另一个放后 n/2个数。

比如 5 3 6 4

5 放到大根堆里，第二个数进来，5>3 ,将 3放到5下面。此时第一个堆里有2个数，第二个里有0个数。2-0>=2。将第一个堆的堆顶的数放入第二个堆，即小根堆，此时第一个堆里只有3 ，第二个里只有5 。

6 进来， 放入小根堆

3 5 6

4进来， 4比3 大，进小根堆，但是此时小根堆里有三个数，3-1>=2 ,所以将小根堆的堆顶弹出到大根堆。

此时：

3 4 56

大根堆堆顶为4，小根堆堆顶为5，中位数便可找到。

 

	public static class MedianHolder {
		private PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(new MaxHeapComparator());
		private PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>(new MinHeapComparator());

		private void modifyTwoHeapsSize() {
            //如果一个堆的size-另一个堆的size >2  弹出栈顶到另一个栈中
			if (this.maxHeap.size() == this.minHeap.size() + 2) {
				this.minHeap.add(this.maxHeap.poll());
			}
			if (this.minHeap.size() == this.maxHeap.size() + 2) {
				this.maxHeap.add(this.minHeap.poll());
			}
		}

		public void addNumber(int num) {
			if (this.maxHeap.isEmpty()) {
                //先加入大根堆 
				this.maxHeap.add(num);
				return;
			}
			if (this.maxHeap.peek() >= num) {
                //如果大根堆的堆顶大于等于此时的num
				this.maxHeap.add(num);
			} else {
				if (this.minHeap.isEmpty()) {
                    //如果小于  将新来的数加到小根堆里
					this.minHeap.add(num);
					return;
				}
				if (this.minHeap.peek() > num) {
					this.maxHeap.add(num);
				} else {
					this.minHeap.add(num);
				}
			}
			modifyTwoHeapsSize();
            //判断此时两个栈是否需要交换
		}

		public Integer getMedian() {
            //得到中位数
			int maxHeapSize = this.maxHeap.size();
			int minHeapSize = this.minHeap.size();
			if (maxHeapSize + minHeapSize == 0) {
				return null;
			}
			Integer maxHeapHead = this.maxHeap.peek();
			Integer minHeapHead = this.minHeap.peek();
			if (((maxHeapSize + minHeapSize) & 1) == 0) {
				return (maxHeapHead + minHeapHead) / 2;
			}
			return maxHeapSize > minHeapSize ? maxHeapHead : minHeapHead;
		}

	}

	public static class MaxHeapComparator implements Comparator<Integer> {
        //定义比较器，比较的是数值，小的在前。
		@Override
		public int compare(Integer o1, Integer o2) {
			if (o2 > o1) {
				return 1;
			} else {
				return -1;
			}
		}
	}

	public static class MinHeapComparator implements Comparator<Integer> {
		@Override
		public int compare(Integer o1, Integer o2) {
			if (o2 < o1) {
				return 1;
			} else {
				return -1;
			}
		}
	}

	// for test
	public static int[] getRandomArray(int maxLen, int maxValue) {
		int[] res = new int[(int) (Math.random() * maxLen) + 1];
		for (int i = 0; i != res.length; i++) {
			res[i] = (int) (Math.random() * maxValue);
		}
		return res;
	}

	// for test, this method is ineffective but absolutely right
	public static int getMedianOfArray(int[] arr) {
		int[] newArr = Arrays.copyOf(arr, arr.length);
		Arrays.sort(newArr);
		int mid = (newArr.length - 1) / 2;
		if ((newArr.length & 1) == 0) {
			return (newArr[mid] + newArr[mid + 1]) / 2;
		} else {
			return newArr[mid];
		}
	}

	public static void printArray(int[] arr) {
		for (int i = 0; i != arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
        int len = 5;
        int maxValue = 10;
        int[] arr = getRandomArray(len, maxValue);
        printArray(arr);
        System.out.println(getMedianOfArray(arr));

            MedianHolder medianHold = new MedianHolder();
            for (int j = 0; j != arr.length; j++) {
                medianHold.addNumber(arr[j]);
            }

        System.out.println(medianHold.getMedian());

	}

 

 

微软折纸问题

 

它的折痕是一棵左子树的节点都为下，右子树的节点都为上的一棵二叉树。

空间复杂度为O（n），即树的高度。

提示的地方在于，折n次，出来2^n -1 条折痕。

大佬写得递归版本，自己在纸上画画过程好理解些：

	public static void printAllFolds(int N) {
		printProcess(1, N, true);
	}

	public static void printProcess(int i, int N, boolean down) {
		if (i > N) {
			return;
		}
		printProcess(i + 1, N, true);
		System.out.println(down ? "down " : "up ");
		printProcess(i + 1, N, false);
	}

	public static void main(String[] args) {
		int N = 4;
		printAllFolds(N);

	}