C++ (Cpp) rb_max_value Examples

Example #1

File: recommended_items.c Project: selim-namsi/Recommender

void
insert_recommended_item(size_t index, float _value, recommended_items_t* items)
{
	recommended_item_t* item = NULL;
	rb_node_t* deleted_item = NULL;

	if (!items)
		return;

	if (!items->filled_items_nb)
		items->raduis = _value;

	if (items->filled_items_nb < items->items_number)
	{
		items->filled_items_nb++;
		items->raduis = fmax(items->raduis, _value);

		item = malloc(sizeof(recommended_item_t));

		if (item)
		{
			item->index = index;
			item->rating = _value;
		}

		rb_insert_value(items->items, item);

	} else if (_value > items->raduis) {

		deleted_item = rb_delete_min_element(items->items);

		/* Recycle deleted element */
		if (deleted_item)
		{
			item = (recommended_item_t*) deleted_item->value;

			if (item)
			{
				item->index = index;
				item->rating = _value;
			}

			rb_insert(items->items, deleted_item);

			items->raduis = get_item_rating_from_node(rb_max_value(items->items));
		}
	}
}

Example #2

File: test_red_black_tree_1.c Project: selim-namsi/Recommender

int test_red_black_tree_1(void)
{
	red_black_tree_t* tree_1 = init_red_black_tree(cmp_rb_node_value, 
								destruct_rb_node_value, 
								copy_rb_node_value);


	red_black_tree_t* tree_2 = init_red_black_tree(cmp_rb_node_value, 
								destruct_rb_node_value, 
								copy_rb_node_value);

	int i;
	int n;

	void* node = NULL;

	int* sorted_values = malloc(MAX_TREE_VALUES * sizeof(int));
	int* values = malloc(MAX_TREE_VALUES * sizeof(int));

	printf("Test red black tree ... \n");

	assert(tree_1);
	assert(tree_2);

	if (!tree_1 || !tree_2)
		return 1;

	if (!values)
		return 1;

	if (!sorted_values)
		return 1;

	node = rb_max_value(tree_1);

	assert(node == NULL);

	node = rb_min_value(tree_1);

	assert(node == NULL);

	srand ( SEED_VALUE );
	
	for (i = 0; i < MAX_TREE_VALUES; i++)
	{
		n = rand();
		values[i] = n;
		sorted_values[i] = n;

		rb_insert_value(tree_1, new_rb_node_value(n));
		rb_insert_value(tree_2, new_rb_node_value(n));
	}

	qsort(sorted_values, MAX_TREE_VALUES, sizeof(int), cmp_integer);

	n = get_rb_node_value_from_node(rb_max_value(tree_1));

	assert(n == sorted_values[MAX_TREE_VALUES - 1]);

	n = get_rb_node_value_from_node(rb_min_value(tree_1));

	assert(n == sorted_values[0]);

	for (i = 0; i < MAX_TREE_VALUES - 1; i++)
	{
		rb_delete_min_element(tree_1);

		n = get_rb_node_value_from_node(rb_min_value(tree_1));
		assert(sorted_values[i + 1] == n);

		n = get_rb_node_value_from_node(rb_max_value(tree_1));

		assert(n == sorted_values[MAX_TREE_VALUES - 1]);
	}

	for (i = 0; i < MAX_TREE_VALUES - 1; i++)
	{
		rb_delete_max_element(tree_2);
		n = get_rb_node_value_from_node(rb_max_value(tree_2));
		assert(sorted_values[MAX_TREE_VALUES - i - 2] == n);

		n = get_rb_node_value_from_node(rb_min_value(tree_2));

		assert(n == sorted_values[0]);
	}

	rb_delete_tree(tree_1);
	rb_delete_tree(tree_2);

	free(values);
	free(sorted_values);

	printf("Test red black tree [OK] \n");

	return 0;
}

Example #3

File: median.c Project: elvinxiao/dml

static void * find_left_max(MTrace * m){
    return rb_max_value(m->rb1);
}