维持中位数的方法？

双堆：令数组L的中位数为m，用一个最大堆存储数组L中不大于m的元素，用一个最小堆存储数组L中不小于m的元素，其中这两个堆均不包含中位数m。每次往数组L插入新元素x时，若x<m，则将其插入最大堆（因为最大堆的最大值不大于m），否则插入最小堆（最小堆的最小值不小于m）。若插入新元素后导致m不再是中位数（即两个堆的元素数目相差2个或2个以上），则将当前的中位数m插入到元素数量较少的那个堆中，然后令元素数量较多的那个堆的堆顶元素为新的中位数，并将该堆顶元素从堆中删除。

#include <stdio.h>


void adjust_min_heap(int *arr, int pos, int len);
void adjust_max_heap(int *arr, int pos, int len);
void create_min_heap(int *arr, int len);
void create_max_heap(int *arr, int len);
void min_heap_sort(int *arr, int len);
void max_heap_sort(int *arr, int len);

void create_max_heap(int *arr, int len)
{
	int i;
	int scope = len / 2;
	while (scope >= 0) {
		adjust_heap(arr, scope--, len);
	}
}

void adjust_max_heap(int *arr, int pos, int len)
{
	int right, left;
	int k = pos;

	left = 2 * pos;
	right = left + 1;
	
	if (left >= len) {
		return;
	}

	if ( arr[k] < arr[left]) {
		k = left;
	}
	if (right < len && arr[k] < arr[right]) {
		k = right;
	}
	
	if (pos != k) {
		int tmp = arr[k];
		arr[k] = arr[pos];
		arr[pos] = tmp;
		adjust_max_heap(arr, k, len);
	}	
}
void max_heap_sort(int *arr, int len)
{
	int tmp;
	create_max_heap(arr, len);
	while (len > 0) {
		tmp = arr[0];
		arr[0] = arr[len - 1];
		arr[len - 1] = tmp;
		adjust_max_heap(arr, 0, --len);
	}
}





void create_min_heap(int *arr, int len)
{
	int i;
	int scope = len / 2;
	while (scope >= 0) {
		adjust_min_heap(arr, scope--, len);
	}
}

void adjust_min_heap(int *arr, int pos, int len)
{
	int right, left;
	int k = pos;

	left = 2 * pos;
	right = left + 1;
	
	if (left >= len) {
		return;
	}

	if ( arr[k] > arr[left]) {
		k = left;
	}
	if (right < len && arr[k] > arr[right]) {
		k = right;
	}
	
	if (pos != k) {
		int tmp = arr[k];
		arr[k] = arr[pos];
		arr[pos] = tmp;
		adjust_min_heap(arr, k, len);
	}	
}
void min_heap_sort(int *arr, int len)
{
	int tmp;
	create_min_heap(arr, len);
	while (len > 0) {
		tmp = arr[0];
		arr[0] = arr[len - 1];
		arr[len - 1] = tmp;
		adjust_min_heap(arr, 0, --len);
	}
}

int median(int *max_heap, int *max_heap_len,
	   	int *min_heap, int *min_heap_len, int median, int input)
{
	int diff;
	int new_median;
	if (input < median) {
		max_heap[*max_heap_len] = input;
		*max_heap_len += 1;
		create_max_heap(max_heap, *max_heap_len);
	}
	else {
		min_heap[*min_heap_len] = input;
		*min_heap_len += 1;
		create_min_heap(max_heap, *max_heap_len);
	}
	
	diff = *min_heap_len - *max_heap_len;
	if (diff < 2 && diff > -2) {
		return median;
	}
	else if (diff <= -2) {
		min_heap[*min_heap_len] = median;
		*min_heap_len += 1;
		create_min_heap(min_heap, *min_heap_len);
		new_median = max_heap[0];
		*max_heap_len -= 1;
		max_heap[0] = max_heap[*max_heap_len];
		adjust_max_heap(max_heap, 0, *max_heap_len);
	} 
	else {
		max_heap[*max_heap_len] = median;
		*max_heap_len += 1;
		create_max_heap(max_heap, *max_heap_len);
		new_median = min_heap[0];
		*min_heap_len -= 1;
		min_heap[0] = min_heap[*min_heap_len];
		adjust_min_heap(min_heap, 0, *min_heap_len);
	}

	return new_median;
}