void insert_review(long long val) {
if (input < 3) {
insert_max(val);
return;
}
long third = input/3;
long size = min_heap.size() - 1;
long long temp;
if (size < third) {
// can add logic
if (val > max_heap[1]) {
insert_min(val);
}
else {
temp = delete_max();
if (temp != -1) insert_min(temp);
insert_max(val);
}
}
else {
// can't add logic
if (val > min_heap[1]) {
temp = delete_min();
insert_min(val);
if (temp != -1) insert_max(temp);
} else {
insert_max(val);
}
}
}
//Deletion in Median Heap
int del_med(Heap H,int n)
{
//Returns root of max heap if N2 = N1
//Returns root of min heap if N2 = N1 + 1
if(H.size_max == n - H.size_min-1)
return delete_max(H,n);
else
return delete_min(H,n);
}
/* dont use the return value */
struct node* delete_max(struct node *root, int free_memory)
{
struct node *replace = NULL;
if(root && root->right == NULL) {
replace = root->left;
if(free_memory) free(root);
return replace;
}
root->right = delete_max(root->right, free_memory);
root->count = 1 + get_size(root->left) + get_size(root->right);
return root;
}
bst_t delete_max(bst_t bst) {
bst_t current;
if (bst != NULL) {
if (bst->right == NULL) {
current = bst->left;
/* Free the allocated resources */
bst->pair = pair_destroy(bst->pair);
free(bst);
bst = current;
} else {
bst->right = delete_max(bst->right);
}
}
return (bst);
}
static rbtree_node* delete_max(rbtree_node *h, VALUE *deleted_value) {
if ( isred(h->left) )
h = rotate_right(h);
if ( !h->right ) {
*deleted_value = h->value;
free(h);
return NULL;
}
if ( !isred(h->right) && !isred(h->right->left) )
h = move_red_right(h);
h->right = delete_max(h->right, deleted_value);
return fixup(h);
}
bst_t bst_remove(bst_t bst, index_t index) {
bst_t current;
if (bst != NULL) {
if (index_is_less_than(index, pair_fst(bst->pair))) {
bst->left = bst_remove(bst->left, index);
} else if (index_is_equal(pair_fst(bst->pair), index) &&
bst->left == NULL) {
current = bst->right;
bst->pair = pair_destroy(bst->pair);
free(bst);
bst = current;
} else if (index_is_equal(pair_fst(bst->pair), index) &&
bst->left != NULL) {
bst->pair = pair_destroy(bst->pair);
bst->pair = bst_max(bst->left);
bst->left = delete_max(bst->left);
} else {
bst->right = bst_remove(bst->right, index);
}
}
return (bst);
}
//Insertion in Median Heap
int insert_med(Heap H,int n,int x)
{
int med = median(H,n);
int j;
if(x<=med)
{
if(H.size_max == n - H.size_min-1)
{
//Deletes root from max heap and inserts in the min heap
//Inserts new element in the max heap
int del = delete_max(H,n);
H.size_max--;
max_insert(H,x,n);
H.size_max++;
min_insert(H,del,n);
H.size_min--;
return 2;
}
else
{
//Inserts new element in the max heap
max_insert(H,x,n);
H.size_max++;
return 1;
}
}
else
{
if(H.size_max == n - H.size_min-1)
{
//Inserts new element in the min heap
min_insert(H,x,n);
H.size_min--;
return 2;
}
else
{
//Deletes root from min heap and inserts in the max heap
//Inserts new element in the min heap
int del = delete_min(H,n);
H.size_min++;
max_insert(H,del,n);
H.size_max++;
min_insert(H,x,n);
H.size_min--;
return 1;
}
}
}
