Imagelibrary/Containers
1
0
Fork 0
mirror of https://github.com/bkthomps/Containers.git synced 2025-11-16 04:24:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reduce calls to malloc in multiset (#100)

Browse Source 
Reduce the number of malloc calls in multiset. Improves efficiency by 30%.
This commit is contained in:
Bailey Thompson
2020-08-15 01:52:54 -04:00
committed by GitHub
parent aab2a074d5
commit ac725ef147
5 changed files with 373 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
containers.h
View File

@@ -385,12 +385,12 @@ multiset multiset_init(size_t key_size,
const void *const two));
/* Capacity */
int multiset_size(multiset me);
size_t multiset_size(multiset me);
int multiset_is_empty(multiset me);
/* Accessing */
int multiset_put(multiset me, void *key);
int multiset_count(multiset me, void *key);
size_t multiset_count(multiset me, void *key);
int multiset_contains(multiset me, void *key);
int multiset_remove(multiset me, void *key);
int multiset_remove_all(multiset me, void *key);

6
src/include/multiset.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2017-2019 Bailey Thompson
* Copyright (c) 2017-2020 Bailey Thompson
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@@ -37,12 +37,12 @@ multiset multiset_init(size_t key_size,
const void *const two));
/* Capacity */
int multiset_size(multiset me);
size_t multiset_size(multiset me);
int multiset_is_empty(multiset me);
/* Accessing */
int multiset_put(multiset me, void *key);
int multiset_count(multiset me, void *key);
size_t multiset_count(multiset me, void *key);
int multiset_contains(multiset me, void *key);
int multiset_remove(multiset me, void *key);
int multiset_remove_all(multiset me, void *key);

546
src/multiset.c
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2017-2019 Bailey Thompson
* Copyright (c) 2017-2020 Bailey Thompson
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
@@ -25,20 +25,22 @@
#include "include/multiset.h"
struct internal_multiset {
size_t size;
size_t key_size;
int (*comparator)(const void *const one, const void *const two);
int size;
struct node *root;
char *root;
};
struct node {
int count;
struct node *parent;
int balance;
void *key;
struct node *left;
struct node *right;
};
static const size_t ptr_size = sizeof(char *);
static const size_t count_size = sizeof(size_t);
/* Node balance is always the first byte (at index 0). */
static const size_t node_count_offset = sizeof(signed char);
static const size_t node_parent_offset = 1 + sizeof(size_t);
static const size_t node_left_child_offset =
1 + sizeof(size_t) + sizeof(char *);
static const size_t node_right_child_offset =
1 + sizeof(size_t) + 2 * sizeof(char *);
static const size_t node_key_offset = 1 + sizeof(size_t) + 3 * sizeof(char *);
/**
* Initializes a multi-set.
@@ -64,9 +66,9 @@ multiset multiset_init(const size_t key_size,
if (!init) {
return NULL;
}
init->size = 0;
init->key_size = key_size;
init->comparator = comparator;
init->size = 0;
init->root = NULL;
return init;
}
@@ -78,7 +80,7 @@ multiset multiset_init(const size_t key_size,
*
* @return the size of the multi-set
*/
int multiset_size(multiset me)
size_t multiset_size(multiset me)
{
return me->size;
}
@@ -98,70 +100,73 @@ int multiset_is_empty(multiset me)
/*
* Resets the parent reference.
*/
static void multiset_reference_parent(multiset me,
struct node *const parent,
struct node *const child)
static void multiset_reference_parent(multiset me, char *const parent,
char *const child)
{
child->parent = parent->parent;
if (!parent->parent) {
char *grand_parent;
char *grand_parent_left_child;
memcpy(child + node_parent_offset, parent + node_parent_offset, ptr_size);
memcpy(&grand_parent, parent + node_parent_offset, ptr_size);
if (!grand_parent) {
me->root = child;
} else if (parent->parent->left == parent) {
parent->parent->left = child;
return;
}
memcpy(&grand_parent_left_child, grand_parent + node_left_child_offset,
ptr_size);
if (grand_parent_left_child == parent) {
memcpy(grand_parent + node_left_child_offset, &child, ptr_size);
} else {
parent->parent->right = child;
memcpy(grand_parent + node_right_child_offset, &child, ptr_size);
}
}
/*
* Rotates the AVL tree to the left.
*/
static void multiset_rotate_left(multiset me,
struct node *const parent,
struct node *const child)
static void multiset_rotate_left(multiset me, char *const parent,
char *const child)
{
struct node *grand_child;
char *left_grand_child;
multiset_reference_parent(me, parent, child);
grand_child = child->left;
if (grand_child) {
grand_child->parent = parent;
memcpy(&left_grand_child, child + node_left_child_offset, ptr_size);
if (left_grand_child) {
memcpy(left_grand_child + node_parent_offset, &parent, ptr_size);
}
parent->parent = child;
parent->right = grand_child;
child->left = parent;
memcpy(parent + node_parent_offset, &child, ptr_size);
memcpy(parent + node_right_child_offset, &left_grand_child, ptr_size);
memcpy(child + node_left_child_offset, &parent, ptr_size);
}
/*
* Rotates the AVL tree to the right.
*/
static void multiset_rotate_right(multiset me,
struct node *const parent,
struct node *const child)
static void multiset_rotate_right(multiset me, char *const parent,
char *const child)
{
struct node *grand_child;
char *right_grand_child;
multiset_reference_parent(me, parent, child);
grand_child = child->right;
if (grand_child) {
grand_child->parent = parent;
memcpy(&right_grand_child, child + node_right_child_offset, ptr_size);
if (right_grand_child) {
memcpy(right_grand_child + node_parent_offset, &parent, ptr_size);
}
parent->parent = child;
parent->left = grand_child;
child->right = parent;
memcpy(parent + node_parent_offset, &child, ptr_size);
memcpy(parent + node_left_child_offset, &right_grand_child, ptr_size);
memcpy(child + node_right_child_offset, &parent, ptr_size);
}
/*
* Performs a left repair.
*/
static struct node *multiset_repair_left(multiset me,
struct node *const parent,
struct node *const child)
static char *multiset_repair_left(multiset me, char *const parent,
char *const child)
{
multiset_rotate_left(me, parent, child);
if (child->balance == 0) {
parent->balance = 1;
child->balance = -1;
if (child[0] == 0) {
parent[0] = 1;
child[0] = -1;
} else {
parent->balance = 0;
child->balance = 0;
parent[0] = 0;
child[0] = 0;
}
return child;
}
@@ -169,17 +174,16 @@ static struct node *multiset_repair_left(multiset me,
/*
* Performs a right repair.
*/
static struct node *multiset_repair_right(multiset me,
struct node *const parent,
struct node *const child)
static char *multiset_repair_right(multiset me, char *const parent,
char *const child)
{
multiset_rotate_right(me, parent, child);
if (child->balance == 0) {
parent->balance = -1;
child->balance = 1;
if (child[0] == 0) {
parent[0] = -1;
child[0] = 1;
} else {
parent->balance = 0;
child->balance = 0;
parent[0] = 0;
child[0] = 0;
}
return child;
}
@@ -187,48 +191,46 @@ static struct node *multiset_repair_right(multiset me,
/*
* Performs a left-right repair.
*/
static struct node *multiset_repair_left_right(multiset me,
struct node *const parent,
struct node *const child,
struct node *const grand_child)
static char *multiset_repair_left_right(multiset me, char *const parent,
char *const child,
char *const grand_child)
{
multiset_rotate_left(me, child, grand_child);
multiset_rotate_right(me, parent, grand_child);
if (grand_child->balance == 1) {
parent->balance = 0;
child->balance = -1;
} else if (grand_child->balance == 0) {
parent->balance = 0;
child->balance = 0;
if (grand_child[0] == 1) {
parent[0] = 0;
child[0] = -1;
} else if (grand_child[0] == 0) {
parent[0] = 0;
child[0] = 0;
} else {
parent->balance = 1;
child->balance = 0;
parent[0] = 1;
child[0] = 0;
}
grand_child->balance = 0;
grand_child[0] = 0;
return grand_child;
}
/*
* Performs a right-left repair.
*/
static struct node *multiset_repair_right_left(multiset me,
struct node *const parent,
struct node *const child,
struct node *const grand_child)
static char *multiset_repair_right_left(multiset me, char *const parent,
char *const child,
char *const grand_child)
{
multiset_rotate_right(me, child, grand_child);
multiset_rotate_left(me, parent, grand_child);
if (grand_child->balance == 1) {
parent->balance = -1;
child->balance = 0;
} else if (grand_child->balance == 0) {
parent->balance = 0;
child->balance = 0;
if (grand_child[0] == 1) {
parent[0] = -1;
child[0] = 0;
} else if (grand_child[0] == 0) {
parent[0] = 0;
child[0] = 0;
} else {
parent->balance = 0;
child->balance = 1;
parent[0] = 0;
child[0] = 1;
}
grand_child->balance = 0;
grand_child[0] = 0;
return grand_child;
}
@@ -236,18 +238,16 @@ static struct node *multiset_repair_right_left(multiset me,
* Repairs the AVL tree on insert. The only possible values of parent->balance
* are {-2, 2} and the only possible values of child->balance are {-1, 0, 1}.
*/
static struct node *multiset_repair(multiset me,
struct node *const parent,
struct node *const child,
struct node *const grand_child)
static char *multiset_repair(multiset me, char *const parent,
char *const child, char *const grand_child)
{
if (parent->balance == 2) {
if (child->balance == -1) {
if (parent[0] == 2) {
if (child[0] == -1) {
return multiset_repair_right_left(me, parent, child, grand_child);
}
return multiset_repair_left(me, parent, child);
}
if (child->balance == 1) {
if (child[0] == 1) {
return multiset_repair_left_right(me, parent, child, grand_child);
}
return multiset_repair_right(me, parent, child);
@@ -256,55 +256,53 @@ static struct node *multiset_repair(multiset me,
/*
* Balances the AVL tree on insert.
*/
static void multiset_insert_balance(multiset me, struct node *const item)
static void multiset_insert_balance(multiset me, char *const item)
{
struct node *grand_child = NULL;
struct node *child = item;
struct node *parent = item->parent;
char *grand_child = NULL;
char *child = item;
char *parent;
memcpy(&parent, item + node_parent_offset, ptr_size);
while (parent) {
if (parent->left == child) {
parent->balance--;
char *parent_left;
memcpy(&parent_left, parent + node_left_child_offset, ptr_size);
if (parent_left == child) {
parent[0]--;
} else {
parent->balance++;
parent[0]++;
}
/* If balance is zero after modification, then the tree is balanced. */
if (parent->balance == 0) {
if (parent[0] == 0) {
return;
}
/* Must re-balance if not in {-1, 0, 1} */
if (parent->balance > 1 || parent->balance < -1) {
if (parent[0] > 1 || parent[0] < -1) {
/* After one repair, the tree is balanced. */
multiset_repair(me, parent, child, grand_child);
return;
}
grand_child = child;
child = parent;
parent = parent->parent;
memcpy(&parent, parent + node_parent_offset, ptr_size);
}
}
/*
* Creates and allocates a node.
*/
static struct node *multiset_create_node(multiset me,
const void *const data,
struct node *const parent)
static char *multiset_create_node(multiset me, const void *const data,
char *const parent)
{
struct node *const insert = malloc(sizeof(struct node));
char *insert = malloc(1 + count_size + 3 * ptr_size + me->key_size);
const size_t one = 1;
if (!insert) {
return NULL;
}
insert->count = 1;
insert->parent = parent;
insert->balance = 0;
insert->key = malloc(me->key_size);
if (!insert->key) {
free(insert);
return NULL;
}
memcpy(insert->key, data, me->key_size);
insert->left = NULL;
insert->right = NULL;
insert[0] = 0;
memcpy(insert + node_count_offset, &one, count_size);
memcpy(insert + node_parent_offset, &parent, ptr_size);
memset(insert + node_left_child_offset, 0, ptr_size);
memset(insert + node_right_child_offset, 0, ptr_size);
memcpy(insert + node_key_offset, data, me->key_size);
me->size++;
return insert;
}
@@ -324,9 +322,9 @@ static struct node *multiset_create_node(multiset me,
*/
int multiset_put(multiset me, void *const key)
{
struct node *traverse;
char *traverse;
if (!me->root) {
struct node *insert = multiset_create_node(me, key, NULL);
char *insert = multiset_create_node(me, key, NULL);
if (!insert) {
return -ENOMEM;
}
@@ -335,33 +333,41 @@ int multiset_put(multiset me, void *const key)
}
traverse = me->root;
for (;;) {
const int compare = me->comparator(key, traverse->key);
const int compare = me->comparator(key, traverse + node_key_offset);
if (compare < 0) {
if (traverse->left) {
traverse = traverse->left;
char *traverse_left;
memcpy(&traverse_left, traverse + node_left_child_offset, ptr_size);
if (traverse_left) {
traverse = traverse_left;
} else {
struct node *insert = multiset_create_node(me, key, traverse);
char *insert = multiset_create_node(me, key, traverse);
if (!insert) {
return -ENOMEM;
}
traverse->left = insert;
memcpy(traverse + node_left_child_offset, &insert, ptr_size);
multiset_insert_balance(me, insert);
return 0;
}
} else if (compare > 0) {
if (traverse->right) {
traverse = traverse->right;
char *traverse_right;
memcpy(&traverse_right, traverse + node_right_child_offset,
ptr_size);
if (traverse_right) {
traverse = traverse_right;
} else {
struct node *insert = multiset_create_node(me, key, traverse);
char *insert = multiset_create_node(me, key, traverse);
if (!insert) {
return -ENOMEM;
}
traverse->right = insert;
memcpy(traverse + node_right_child_offset, &insert, ptr_size);
multiset_insert_balance(me, insert);
return 0;
}
} else {
traverse->count++;
size_t count;
memcpy(&count, traverse + node_count_offset, count_size);
count++;
memcpy(traverse + node_count_offset, &count, count_size);
me->size++;
return 0;
}
@@ -371,23 +377,28 @@ int multiset_put(multiset me, void *const key)
/*
* If a match occurs, returns the match. Else, returns NULL.
*/
static struct node *multiset_equal_match(multiset me, const void *const key)
static char *multiset_equal_match(multiset me, const void *const key)
{
struct node *traverse = me->root;
char *traverse = me->root;
if (!traverse) {
return 0;
return NULL;
}
for (;;) {
const int compare = me->comparator(key, traverse->key);
const int compare = me->comparator(key, traverse + node_key_offset);
if (compare < 0) {
if (traverse->left) {
traverse = traverse->left;
char *traverse_left;
memcpy(&traverse_left, traverse + node_left_child_offset, ptr_size);
if (traverse_left) {
traverse = traverse_left;
} else {
return NULL;
}
} else if (compare > 0) {
if (traverse->right) {
traverse = traverse->right;
char *traverse_right;
memcpy(&traverse_right, traverse + node_right_child_offset,
ptr_size);
if (traverse_right) {
traverse = traverse_right;
} else {
return NULL;
}
@@ -409,13 +420,15 @@ static struct node *multiset_equal_match(multiset me, const void *const key)
*
* @return the count of a specific key in the multi-set
*/
int multiset_count(multiset me, void *const key)
size_t multiset_count(multiset me, void *const key)
{
const struct node *const item = multiset_equal_match(me, key);
const char *const item = multiset_equal_match(me, key);
size_t item_count;
if (!item) {
return 0;
}
return item->count;
memcpy(&item_count, item + node_count_offset, count_size);
return item_count;
}
/**
@@ -438,45 +451,56 @@ int multiset_contains(multiset me, void *const key)
/*
* Repairs the AVL tree by pivoting on an item.
*/
static struct node *multiset_repair_pivot(multiset me,
struct node *const item,
const int is_left_pivot)
static char *multiset_repair_pivot(multiset me, char *const item,
const int is_left_pivot)
{
struct node *const child = is_left_pivot ? item->right : item->left;
struct node *const grand_child =
child->balance == 1 ? child->right : child->left;
char *child;
char *grand_child;
char *item_right;
char *item_left;
char *child_right;
char *child_left;
memcpy(&item_right, item + node_right_child_offset, ptr_size);
memcpy(&item_left, item + node_left_child_offset, ptr_size);
child = is_left_pivot ? item_right : item_left;
memcpy(&child_right, child + node_right_child_offset, ptr_size);
memcpy(&child_left, child + node_left_child_offset, ptr_size);
grand_child = child[0] == 1 ? child_right : child_left;
return multiset_repair(me, item, child, grand_child);
}
/*
* Goes back up the tree repairing it along the way.
*/
static void multiset_trace_ancestors(multiset me, struct node *item)
static void multiset_trace_ancestors(multiset me, char *item)
{
struct node *child = item;
struct node *parent = item->parent;
char *child = item;
char *parent;
memcpy(&parent, item + node_parent_offset, ptr_size);
while (parent) {
if (parent->left == child) {
parent->balance++;
char *parent_left;
memcpy(&parent_left, parent + node_left_child_offset, ptr_size);
if (parent_left == child) {
parent[0]++;
} else {
parent->balance--;
parent[0]--;
}
/* The tree is balanced if balance is -1 or +1 after modification. */
if (parent->balance == -1 || parent->balance == 1) {
if (parent[0] == -1 || parent[0] == 1) {
return;
}
/* Must re-balance if not in {-1, 0, 1} */
if (parent->balance > 1 || parent->balance < -1) {
child = multiset_repair_pivot(me, parent, parent->left == child);
parent = child->parent;
/* If balance is -1 or +1 after modification or the parent is */
/* NULL, then the tree is balanced. */
if (!parent || child->balance == -1 || child->balance == 1) {
if (parent[0] > 1 || parent[0] < -1) {
child = multiset_repair_pivot(me, parent, parent_left == child);
memcpy(&parent, child + node_parent_offset, ptr_size);
/* If balance is -1 or +1 after modification or */
/* the parent is NULL, then the tree is balanced. */
if (!parent || child[0] == -1 || child[0] == 1) {
return;
}
} else {
child = parent;
parent = parent->parent;
memcpy(&parent, parent + node_parent_offset, ptr_size);
}
}
}
@@ -484,23 +508,24 @@ static void multiset_trace_ancestors(multiset me, struct node *item)
/*
* Balances the AVL tree on deletion.
*/
static void multiset_delete_balance(multiset me,
struct node *item,
static void multiset_delete_balance(multiset me, char *item,
const int is_left_deleted)
{
if (is_left_deleted) {
item->balance++;
item[0]++;
} else {
item->balance--;
item[0]--;
}
/* If balance is -1 or +1 after modification, then the tree is balanced. */
if (item->balance == -1 || item->balance == 1) {
if (item[0] == -1 || item[0] == 1) {
return;
}
/* Must re-balance if not in {-1, 0, 1} */
if (item->balance > 1 || item->balance < -1) {
if (item[0] > 1 || item[0] < -1) {
char *item_parent;
item = multiset_repair_pivot(me, item, is_left_deleted);
if (!item->parent || item->balance == -1 || item->balance == 1) {
memcpy(&item_parent, item + node_parent_offset, ptr_size);
if (!item_parent || item[0] == -1 || item[0] == 1) {
return;
}
}
@@ -510,62 +535,80 @@ static void multiset_delete_balance(multiset me,
/*
* Removes traverse when it has no children.
*/
static void multiset_remove_no_children(multiset me,
const struct node *const traverse)
static void multiset_remove_no_children(multiset me, const char *const traverse)
{
struct node *const parent = traverse->parent;
char *traverse_parent;
char *traverse_parent_left;
memcpy(&traverse_parent, traverse + node_parent_offset, ptr_size);
/* If no parent and no children, then the only node is traverse. */
if (!parent) {
if (!traverse_parent) {
me->root = NULL;
return;
}
memcpy(&traverse_parent_left, traverse_parent + node_left_child_offset,
ptr_size);
/* No re-reference needed since traverse has no children. */
if (parent->left == traverse) {
parent->left = NULL;
multiset_delete_balance(me, parent, 1);
if (traverse_parent_left == traverse) {
memset(traverse_parent + node_left_child_offset, 0, ptr_size);
multiset_delete_balance(me, traverse_parent, 1);
} else {
parent->right = NULL;
multiset_delete_balance(me, parent, 0);
memset(traverse_parent + node_right_child_offset, 0, ptr_size);
multiset_delete_balance(me, traverse_parent, 0);
}
}
/*
* Removes traverse when it has one child.
*/
static void multiset_remove_one_child(multiset me,
const struct node *const traverse)
static void multiset_remove_one_child(multiset me, const char *const traverse)
{
struct node *const parent = traverse->parent;
char *traverse_parent;
char *traverse_left;
char *traverse_right;
char *traverse_parent_left;
memcpy(&traverse_parent, traverse + node_parent_offset, ptr_size);
memcpy(&traverse_left, traverse + node_left_child_offset, ptr_size);
memcpy(&traverse_right, traverse + node_right_child_offset, ptr_size);
/* If no parent, make the child of traverse the new root. */
if (!parent) {
if (traverse->left) {
traverse->left->parent = NULL;
me->root = traverse->left;
if (!traverse_parent) {
if (traverse_left) {
memset(traverse_left + node_parent_offset, 0, ptr_size);
me->root = traverse_left;
} else {
traverse->right->parent = NULL;
me->root = traverse->right;
memset(traverse_right + node_parent_offset, 0, ptr_size);
me->root = traverse_right;
}
return;
}
memcpy(&traverse_parent_left, traverse_parent + node_left_child_offset,
ptr_size);
/* The parent of traverse now references the child of traverse. */
if (parent->left == traverse) {
if (traverse->left) {
parent->left = traverse->left;
traverse->left->parent = parent;
if (traverse_parent_left == traverse) {
if (traverse_left) {
memcpy(traverse_parent + node_left_child_offset, &traverse_left,
ptr_size);
memcpy(traverse_left + node_parent_offset, &traverse_parent,
ptr_size);
} else {
parent->left = traverse->right;
traverse->right->parent = parent;
memcpy(traverse_parent + node_left_child_offset, &traverse_right,
ptr_size);
memcpy(traverse_right + node_parent_offset, &traverse_parent,
ptr_size);
}
multiset_delete_balance(me, parent, 1);
multiset_delete_balance(me, traverse_parent, 1);
} else {
if (traverse->left) {
parent->right = traverse->left;
traverse->left->parent = parent;
if (traverse_left) {
memcpy(traverse_parent + node_right_child_offset, &traverse_left,
ptr_size);
memcpy(traverse_left + node_parent_offset, &traverse_parent,
ptr_size);
} else {
parent->right = traverse->right;
traverse->right->parent = parent;
memcpy(traverse_parent + node_right_child_offset, &traverse_right,
ptr_size);
memcpy(traverse_right + node_parent_offset, &traverse_parent,
ptr_size);
}
multiset_delete_balance(me, parent, 0);
multiset_delete_balance(me, traverse_parent, 0);
}
}
@@ -573,41 +616,73 @@ static void multiset_remove_one_child(multiset me,
* Removes traverse when it has two children.
*/
static void multiset_remove_two_children(multiset me,
const struct node *const traverse)
const char *const traverse)
{
struct node *item;
struct node *parent;
const int is_left_deleted = traverse->right->left != NULL;
char *item;
char *item_parent;
char *parent;
char *traverse_parent;
char *traverse_right;
char *traverse_right_left;
int is_left_deleted;
memcpy(&traverse_right, traverse + node_right_child_offset, ptr_size);
memcpy(&traverse_right_left, traverse_right + node_left_child_offset,
ptr_size);
is_left_deleted = traverse_right_left != NULL;
if (!is_left_deleted) {
item = traverse->right;
char *item_left;
memcpy(&item, traverse + node_right_child_offset, ptr_size);
parent = item;
item->balance = traverse->balance;
item->parent = traverse->parent;
item->left = traverse->left;
item->left->parent = item;
item[0] = traverse[0];
memcpy(item + node_parent_offset, traverse + node_parent_offset,
ptr_size);
memcpy(item + node_left_child_offset, traverse + node_left_child_offset,
ptr_size);
memcpy(&item_left, item + node_left_child_offset, ptr_size);
memcpy(item_left + node_parent_offset, &item, ptr_size);
} else {
item = traverse->right->left;
while (item->left) {
item = item->left;
char *item_left;
char *item_right;
item = traverse_right_left;
memcpy(&item_left, item + node_left_child_offset, ptr_size);
while (item_left) {
item = item_left;
memcpy(&item_left, item + node_left_child_offset, ptr_size);
}
parent = item->parent;
item->balance = traverse->balance;
item->parent->left = item->right;
if (item->right) {
item->right->parent = item->parent;
memcpy(&parent, item + node_parent_offset, ptr_size);
item[0] = traverse[0];
memcpy(&item_parent, item + node_parent_offset, ptr_size);
memcpy(item_parent + node_left_child_offset,
item + node_right_child_offset, ptr_size);
memcpy(&item_right, item + node_right_child_offset, ptr_size);
if (item_right) {
memcpy(item_right + node_parent_offset, item + node_parent_offset,
ptr_size);
}
item->left = traverse->left;
item->left->parent = item;
item->right = traverse->right;
item->right->parent = item;
item->parent = traverse->parent;
memcpy(item + node_left_child_offset, traverse + node_left_child_offset,
ptr_size);
memcpy(&item_left, item + node_left_child_offset, ptr_size);
memcpy(item_left + node_parent_offset, &item, ptr_size);
memcpy(item + node_right_child_offset,
traverse + node_right_child_offset, ptr_size);
memcpy(&item_right, item + node_right_child_offset, ptr_size);
memcpy(item_right + node_parent_offset, &item, ptr_size);
memcpy(item + node_parent_offset, traverse + node_parent_offset,
ptr_size);
}
if (!traverse->parent) {
memcpy(&traverse_parent, traverse + node_parent_offset, ptr_size);
if (!traverse_parent) {
me->root = item;
} else if (traverse->parent->left == traverse) {
item->parent->left = item;
} else {
item->parent->right = item;
char *traverse_parent_left;
memcpy(&traverse_parent_left, traverse_parent + node_left_child_offset,
ptr_size);
memcpy(&item_parent, item + node_parent_offset, ptr_size);
if (traverse_parent_left == traverse) {
memcpy(item_parent + node_left_child_offset, &item, ptr_size);
} else {
memcpy(item_parent + node_right_child_offset, &item, ptr_size);
}
}
multiset_delete_balance(me, parent, is_left_deleted);
}
@@ -615,16 +690,19 @@ static void multiset_remove_two_children(multiset me,
/*
* Removes the element from the set.
*/
static void multiset_remove_element(multiset me, struct node *const traverse)
static void multiset_remove_element(multiset me, char *const traverse)
{
if (!traverse->left && !traverse->right) {
char *traverse_left;
char *traverse_right;
memcpy(&traverse_left, traverse + node_left_child_offset, ptr_size);
memcpy(&traverse_right, traverse + node_right_child_offset, ptr_size);
if (!traverse_left && !traverse_right) {
multiset_remove_no_children(me, traverse);
} else if (!traverse->left || !traverse->right) {
} else if (!traverse_left || !traverse_right) {
multiset_remove_one_child(me, traverse);
} else {
multiset_remove_two_children(me, traverse);
}
free(traverse->key);
free(traverse);
}
@@ -642,13 +720,17 @@ static void multiset_remove_element(multiset me, struct node *const traverse)
*/
int multiset_remove(multiset me, void *const key)
{
struct node *const traverse = multiset_equal_match(me, key);
char *const traverse = multiset_equal_match(me, key);
size_t traverse_count;
if (!traverse) {
return 0;
}
traverse->count--;
if (traverse->count == 0) {
memcpy(&traverse_count, traverse + node_count_offset, count_size);
if (traverse_count == 1) {
multiset_remove_element(me, traverse);
} else {
traverse_count--;
memcpy(traverse + node_count_offset, &traverse_count, count_size);
}
me->size--;
return 1;
@@ -668,11 +750,13 @@ int multiset_remove(multiset me, void *const key)
*/
int multiset_remove_all(multiset me, void *const key)
{
struct node *const traverse = multiset_equal_match(me, key);
char *const traverse = multiset_equal_match(me, key);
size_t traverse_count;
if (!traverse) {
return 0;
}
me->size -= traverse->count;
memcpy(&traverse_count, traverse + node_count_offset, count_size);
me->size -= traverse_count;
multiset_remove_element(me, traverse);
return 1;
}

90
tst/test_multiset.c
View File

@@ -1,68 +1,82 @@
#include <memory.h>
#include "test.h"
#include "../src/include/multiset.h"
/*
* Include this struct to verify the tree.
* Include this to verify the tree.
*/
struct internal_multiset {
size_t size;
size_t key_size;
int (*comparator)(const void *const one, const void *const two);
int size;
struct node *root;
char *root;
};
/*
* Include this struct to verify the tree.
* Include this to verify the tree.
*/
struct node {
int count;
struct node *parent;
int balance;
void *key;
struct node *left;
struct node *right;
};
static const size_t ptr_size = sizeof(char *);
/* static const size_t count_size = sizeof(size_t); */
/* Node balance is always the first byte (at index 0). */
/* static const size_t node_count_offset = sizeof(signed char); */
static const size_t node_parent_offset = 1 + sizeof(size_t);
static const size_t node_left_child_offset =
1 + sizeof(size_t) + sizeof(char *);
static const size_t node_right_child_offset =
1 + sizeof(size_t) + 2 * sizeof(char *);
static const size_t node_key_offset = 1 + sizeof(size_t) + 3 * sizeof(char *);
/*
* Verifies that the AVL tree rules are followed. The balance factor of an item
* must be the right height minus the left height. Also, the left key must be
* less than the right key.
*/
static int multiset_verify_recursive(struct node *const item)
static int multiset_verify_recursive(char *const item)
{
int left;
int right;
int max;
char *item_left;
char *item_right;
if (!item) {
return 0;
}
left = multiset_verify_recursive(item->left);
right = multiset_verify_recursive(item->right);
memcpy(&item_left, item + node_left_child_offset, ptr_size);
memcpy(&item_right, item + node_right_child_offset, ptr_size);
left = multiset_verify_recursive(item_left);
right = multiset_verify_recursive(item_right);
max = left > right ? left : right;
assert(right - left == item->balance);
if (item->left && item->right) {
const int left_val = *(int *) item->left->key;
const int right_val = *(int *) item->right->key;
assert(right - left == item[0]);
if (item_left && item_right) {
const int left_val = *(int *) (item_left + node_key_offset);
const int right_val = *(int *) (item_right + node_key_offset);
assert(left_val < right_val);
}
if (item->left) {
assert(item->left->parent == item);
assert(item->left->parent->key == item->key);
if (item_left) {
char *item_left_parent;
memcpy(&item_left_parent, item_left + node_parent_offset, ptr_size);
assert(item_left_parent == item);
assert(item_left_parent + node_key_offset == item + node_key_offset);
}
if (item->right) {
assert(item->right->parent == item);
assert(item->right->parent->key == item->key);
if (item_right) {
char *item_right_parent;
memcpy(&item_right_parent, item_right + node_parent_offset, ptr_size);
assert(item_right_parent == item);
assert(item_right_parent + node_key_offset == item + node_key_offset);
}
return max + 1;
}
static int multiset_compute_size(struct node *const item)
static size_t multiset_compute_size(char *const item)
{
char *left;
char *right;
if (!item) {
return 0;
}
return 1 + multiset_compute_size(item->left) +
multiset_compute_size(item->right);
memcpy(&left, item + node_left_child_offset, ptr_size);
memcpy(&right, item + node_right_child_offset, ptr_size);
return 1 + multiset_compute_size(left) + multiset_compute_size(right);
}
static void multiset_verify(multiset me)
@@ -87,7 +101,7 @@ static void test_invalid_init(void)
static void mutation_order(multiset me, const int *const arr, const int size)
{
int i;
int actual_size = 0;
size_t actual_size = 0;
assert(multiset_is_empty(me));
for (i = 0; i < size; i++) {
int num = arr[i];
@@ -372,7 +386,7 @@ static void test_contains(void)
static void test_stress_add(void)
{
int count = 0;
size_t count = 0;
int flip = 0;
int i;
multiset me = multiset_init(sizeof(int), compare_int);
@@ -475,6 +489,13 @@ static void test_multiple_operations(void)
assert(multiset_count(me, &key) == 1);
key = 5;
assert(multiset_count(me, &key) == 2);
assert(multiset_size(me) == 3);
assert(multiset_remove(me, &key));
assert(multiset_count(me, &key) == 1);
assert(multiset_size(me) == 2);
assert(multiset_remove(me, &key));
assert(multiset_count(me, &key) == 0);
assert(multiset_size(me) == 1);
multiset_remove_all(me, &key);
assert(multiset_size(me) == 1);
key = 7;
@@ -497,9 +518,6 @@ static void test_put_root_out_of_memory(multiset me)
int key = 2;
fail_malloc = 1;
assert(multiset_put(me, &key) == -ENOMEM);
fail_malloc = 1;
delay_fail_malloc = 1;
assert(multiset_put(me, &key) == -ENOMEM);
}
#endif
@@ -509,9 +527,6 @@ static void test_put_on_left_out_of_memory(multiset me)
int key = 1;
fail_malloc = 1;
assert(multiset_put(me, &key) == -ENOMEM);
fail_malloc = 1;
delay_fail_malloc = 1;
assert(multiset_put(me, &key) == -ENOMEM);
}
#endif
@@ -521,9 +536,6 @@ static void test_put_on_right_out_of_memory(multiset me)
int key = 3;
fail_malloc = 1;
assert(multiset_put(me, &key) == -ENOMEM);
fail_malloc = 1;
delay_fail_malloc = 1;
assert(multiset_put(me, &key) == -ENOMEM);
}
#endif

4
tst/test_set.c
View File

@@ -3,7 +3,7 @@
#include "../src/include/set.h"
/*
* Include this struct to verify the tree.
* Include this to verify the tree.
*/
struct internal_set {
size_t size;
@@ -13,7 +13,7 @@ struct internal_set {
};
/*
* Include this struct to verify the tree.
* Include this to verify the tree.
*/
static const size_t ptr_size = sizeof(char *);
/* Node balance is always the first byte (at index 0). */