Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Support
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
C
codes
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
38
Issues
38
List
Boards
Labels
Milestones
Merge Requests
8
Merge Requests
8
Analytics
Analytics
Repository
Value Stream
Wiki
Wiki
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Commits
Issue Boards
Open sidebar
codes
codes
Commits
010ab8a3
Commit
010ab8a3
authored
Aug 14, 2013
by
Philip Carns
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
remove unused interval merge and rb trees
parent
068648d8
Changes
5
Hide whitespace changes
Inline
Side-by-side
Showing
5 changed files
with
0 additions
and
2831 deletions
+0
-2831
src/Makefile.subdir
src/Makefile.subdir
+0
-4
src/util/interval-merge-tree.c
src/util/interval-merge-tree.c
+0
-1495
src/util/interval-merge-tree.h
src/util/interval-merge-tree.h
+0
-160
src/util/red-black-tree.c
src/util/red-black-tree.c
+0
-1049
src/util/red-black-tree.h
src/util/red-black-tree.h
+0
-123
No files found.
src/Makefile.subdir
View file @
010ab8a3
...
...
@@ -88,10 +88,6 @@ src_libcodes_base_a_SOURCES = \
src/modelconfig/txt_configfile.c
\
codes/tools.h
\
src/util/tools.c
\
src/util/interval-merge-tree.h
\
src/util/interval-merge-tree.c
\
src/util/red-black-tree.h
\
src/util/red-black-tree.c
\
src/util/codes-callbacks.h
\
src/util/codes-callbacks.c
\
src/util/codes_mapping.c
\
...
...
src/util/interval-merge-tree.c
deleted
100644 → 0
View file @
068648d8
#include "util/interval-merge-tree.h"
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <pthread.h>
#include <assert.h>
/* rb tree sentinel */
static
size_t
interval_merge_tree_sentinel_key_key
=
0
;
static
size_t
interval_merge_tree_sentinel_key_value
=
0
;
static
interval_merge_tree_key_t
interval_merge_tree_sentinel_key
=
{
&
interval_merge_tree_sentinel_key_key
,
&
interval_merge_tree_sentinel_key_value
};
static
interval_merge_tree_node_t
interval_merge_tree_sentinel
=
{
{
&
interval_merge_tree_sentinel_key_key
,
&
interval_merge_tree_sentinel_key_value
},
NULL
,
NULL
,
NULL
,
0
,
0
,
{
0
,
0
},
NULL
,
NULL
,
RB_TREE_COLOR_BLACK
,
0
,
NULL
};
#define INTERVAL_TREE_LL_POOL_SIZE 4096
#define INTERVAL_TREE_NODE_POOL_SIZE 4096
static
size_t
interval_merge_tree_ll_pool_size
=
0
;
static
size_t
interval_merge_tree_node_pool_size
=
0
;
static
size_t
ll_pool_next
=
0
;
static
size_t
node_pool_next
=
0
;
static
interval_merge_tree_node_t
*
interval_merge_tree_node_pool
=
NULL
;
static
interval_merge_tree_node_t
**
interval_merge_tree_node_pool_index
=
NULL
;
static
interval_merge_tree_node_t
*
interval_merge_tree_node_pool_min
=
NULL
;
static
interval_merge_tree_node_t
*
interval_merge_tree_node_pool_max
=
NULL
;
static
interval_merge_tree_interval_ll_t
*
interval_merge_tree_ll_pool
=
NULL
;
static
interval_merge_tree_interval_ll_t
**
interval_merge_tree_ll_pool_index
=
NULL
;
static
interval_merge_tree_interval_ll_t
*
interval_merge_tree_ll_pool_min
=
NULL
;
static
interval_merge_tree_interval_ll_t
*
interval_merge_tree_ll_pool_max
=
NULL
;
static
inline
int
interval_merge_tree_create_ll_pool
(
size_t
num
)
{
size_t
i
=
0
;
interval_merge_tree_ll_pool
=
(
interval_merge_tree_interval_ll_t
*
)
malloc
(
sizeof
(
interval_merge_tree_interval_ll_t
)
*
num
);
interval_merge_tree_ll_pool_index
=
(
interval_merge_tree_interval_ll_t
**
)
malloc
(
sizeof
(
interval_merge_tree_interval_ll_t
*
)
*
num
);
interval_merge_tree_ll_pool_size
=
num
;
ll_pool_next
=
0
;
interval_merge_tree_ll_pool_min
=
&
(
interval_merge_tree_ll_pool
[
0
]);
interval_merge_tree_ll_pool_max
=
&
(
interval_merge_tree_ll_pool
[
num
-
1
]);
for
(
i
=
0
;
i
<
num
;
i
++
)
{
interval_merge_tree_ll_pool_index
[
i
]
=
&
(
interval_merge_tree_ll_pool
[
i
]);
}
return
0
;
}
static
inline
int
interval_merge_tree_destroy_ll_pool
(
)
{
free
(
interval_merge_tree_ll_pool
);
interval_merge_tree_ll_pool
=
NULL
;
free
(
interval_merge_tree_ll_pool_index
);
interval_merge_tree_ll_pool_index
=
NULL
;
ll_pool_next
=
0
;
interval_merge_tree_ll_pool_size
=
0
;
interval_merge_tree_ll_pool_min
=
NULL
;
interval_merge_tree_ll_pool_max
=
NULL
;
return
0
;
}
static
inline
interval_merge_tree_interval_ll_t
*
interval_merge_tree_alloc_ll
(
)
{
if
(
ll_pool_next
<
interval_merge_tree_ll_pool_size
)
{
return
interval_merge_tree_ll_pool_index
[
ll_pool_next
++
];
}
else
{
return
(
interval_merge_tree_interval_ll_t
*
)
malloc
(
sizeof
(
interval_merge_tree_interval_ll_t
));
}
return
NULL
;
}
static
inline
int
interval_merge_tree_dealloc_ll
(
interval_merge_tree_interval_ll_t
*
node
)
{
if
(
node
>=
interval_merge_tree_ll_pool_min
&&
node
<=
interval_merge_tree_ll_pool_max
)
{
interval_merge_tree_ll_pool_index
[
--
ll_pool_next
]
=
node
;
}
else
{
free
(
node
);
}
return
0
;
}
static
inline
int
interval_merge_tree_create_node_pool
(
size_t
num
)
{
size_t
i
=
0
;
interval_merge_tree_node_pool
=
(
interval_merge_tree_node_t
*
)
malloc
(
sizeof
(
interval_merge_tree_node_t
)
*
num
);
interval_merge_tree_node_pool_index
=
(
interval_merge_tree_node_t
**
)
malloc
(
sizeof
(
interval_merge_tree_node_t
*
)
*
num
);
interval_merge_tree_node_pool_size
=
num
;
node_pool_next
=
0
;
interval_merge_tree_node_pool_min
=
&
(
interval_merge_tree_node_pool
[
0
]);
interval_merge_tree_node_pool_max
=
&
(
interval_merge_tree_node_pool
[
num
-
1
]);
for
(
i
=
0
;
i
<
num
;
i
++
)
{
interval_merge_tree_node_pool_index
[
i
]
=
&
(
interval_merge_tree_node_pool
[
i
]);
}
return
0
;
}
static
inline
int
interval_merge_tree_destroy_node_pool
(
)
{
free
(
interval_merge_tree_node_pool
);
interval_merge_tree_node_pool
=
NULL
;
free
(
interval_merge_tree_node_pool_index
);
interval_merge_tree_node_pool_index
=
NULL
;
interval_merge_tree_node_pool_size
=
0
;
node_pool_next
=
0
;
interval_merge_tree_node_pool_min
=
NULL
;
interval_merge_tree_node_pool_max
=
NULL
;
return
0
;
}
static
inline
interval_merge_tree_node_t
*
interval_merge_tree_alloc_node
(
)
{
if
(
node_pool_next
<
interval_merge_tree_node_pool_size
)
{
return
interval_merge_tree_node_pool_index
[
node_pool_next
++
];
}
else
{
return
(
interval_merge_tree_node_t
*
)
malloc
(
sizeof
(
interval_merge_tree_node_t
));
}
return
NULL
;
}
static
inline
int
interval_merge_tree_dealloc_node
(
interval_merge_tree_node_t
*
node
)
{
if
(
node
>=
interval_merge_tree_node_pool_min
&&
node
<=
interval_merge_tree_node_pool_max
)
{
interval_merge_tree_node_pool_index
[
--
node_pool_next
]
=
node
;
}
else
{
free
(
node
);
}
return
0
;
}
static
inline
interval_merge_tree_interval_ll_t
*
interval_merge_tree_interval_ll_create
(
)
{
interval_merge_tree_interval_ll_t
*
ll
=
(
interval_merge_tree_interval_ll_t
*
)
malloc
(
sizeof
(
interval_merge_tree_interval_ll_t
));
//interval_merge_tree_interval_ll_t * ll = interval_merge_tree_alloc_ll();
ll
->
next
=
NULL
;
ll
->
data
=
NULL
;
ll
->
key
=
NULL
;
return
ll
;
}
inline
int
interval_merge_tree_interval_ll_destroy
(
interval_merge_tree_interval_ll_t
*
ll
)
{
interval_merge_tree_interval_ll_t
*
cur
=
ll
;
interval_merge_tree_interval_ll_t
*
next
=
NULL
;
while
(
cur
)
{
next
=
cur
->
next
;
cur
->
next
=
NULL
;
cur
->
data
=
NULL
;
free
(
cur
);
//interval_merge_tree_dealloc_ll(cur);
cur
=
next
;
}
return
0
;
}
/* copy the n2 list into the n1 list */
static
inline
int
interval_merge_tree_interval_ll_merge
(
interval_merge_tree_node_t
*
n1
,
interval_merge_tree_node_t
**
n2
)
{
interval_merge_tree_interval_ll_t
*
l2_head
=
(
*
n2
)
->
ll_head
;
interval_merge_tree_interval_ll_t
*
l2_tail
=
(
*
n2
)
->
ll_tail
;
if
(
l2_head
&&
l2_tail
)
{
if
(
n1
->
ll_head
&&
n1
->
ll_tail
)
{
/* set the next value after n1 tail to n2 head */
n1
->
ll_tail
->
next
=
l2_head
;
n1
->
ll_tail
=
l2_tail
;
l2_tail
->
next
=
NULL
;
(
*
n2
)
->
ll_head
=
NULL
;
(
*
n2
)
->
ll_tail
=
NULL
;
}
else
{
/* if the current node list was empty, set it to the l2 values */
n1
->
ll_head
=
l2_head
;
n1
->
ll_tail
=
l2_tail
;
l2_tail
->
next
=
NULL
;
(
*
n2
)
->
ll_head
=
NULL
;
(
*
n2
)
->
ll_tail
=
NULL
;
}
}
return
0
;
}
inline
int
interval_merge_tree_interval_ll_init
(
interval_merge_tree_node_t
*
node
,
void
*
data
)
{
/* create the link list for the node and update the head with the data */
node
->
ll_head
=
interval_merge_tree_interval_ll_create
();
node
->
ll_head
->
data
=
data
;
node
->
ll_head
->
key
=
node
->
key
.
key
;
node
->
ll_tail
=
node
->
ll_head
;
return
0
;
}
/* determine the max value for an interval or node */
inline
static
size_t
interval_merge_tree_interval_max
(
interval_merge_tree_node_t
*
node
)
{
if
(
node
->
interval
.
end
>
node
->
left
->
max
)
{
if
(
node
->
interval
.
end
>
node
->
right
->
max
)
{
return
node
->
interval
.
end
;
}
else
/* if(i->end <= node->right->max) */
{
return
node
->
right
->
max
;
}
}
else
/* if(i->end <= node->left->max) */
{
if
(
node
->
left
->
max
>
node
->
right
->
max
)
{
return
node
->
left
->
max
;
}
else
/* if(node->left->max <= node->left->max) */
{
return
node
->
right
->
max
;
}
}
/* should not get here */
return
0
;
}
/* create an empty node */
inline
interval_merge_tree_node_t
*
interval_merge_tree_create_node
(
)
{
interval_merge_tree_node_t
*
node
=
NULL
;
/* try to get a node from the node pool first */
#if 0
node = interval_merge_tree_node_pool_alloc_node();
if(!node)
#endif
{
node
=
(
interval_merge_tree_node_t
*
)
malloc
(
sizeof
(
interval_merge_tree_node_t
));
//node = interval_merge_tree_alloc_node();
node
->
node_pool
=
0
;
}
/* set child and parent pointers to NULL */
node
->
left
=
&
interval_merge_tree_sentinel
;
node
->
right
=
&
interval_merge_tree_sentinel
;
node
->
parent
=
&
interval_merge_tree_sentinel
;
/* set the key to NULL */
node
->
key
.
key
=
NULL
;
node
->
key
.
value
=
NULL
;
/* set to a non-valid color */
node
->
color
=
RB_TREE_COLOR_NONE
;
/* create the interval */
node
->
interval
.
start
=
0
;
node
->
interval
.
end
=
0
;
/* set the max interval value */
node
->
max
=
0
;
/* set the order stat size to 0 */
node
->
size
=
0
;
/* create the link list for intervals... set the head to the tail */
node
->
ll_head
=
NULL
;
node
->
ll_tail
=
node
->
ll_head
;
/* init the consumer to null */
node
->
consumer
=
NULL
;
return
node
;
}
/* destroy a node */
inline
int
interval_merge_tree_destroy_node
(
interval_merge_tree_node_t
*
node
)
{
if
(
node
&&
node
!=
&
interval_merge_tree_sentinel
)
{
node
->
left
=
NULL
;
node
->
right
=
NULL
;
/* destroy the key */
node
->
key
.
key
=
NULL
;
node
->
key
.
value
=
NULL
;
/* do not attempt to destroy the parent node ... just set to NULL */
node
->
parent
=
NULL
;
/* set the color to 0 */
node
->
color
=
0
;
/* set the max interval value */
node
->
max
=
0
;
/* destroy the interval */
node
->
interval
.
start
=
0
;
node
->
interval
.
end
=
0
;
/* erase the pointers to, but do not destroy, the link list */
node
->
ll_head
=
NULL
;
node
->
ll_tail
=
NULL
;
/* destroy the node */
#if 0
if(node->node_pool)
{
interval_merge_tree_node_pool_free_node(node);
}
else
#endif
{
free
(
node
);
//interval_merge_tree_dealloc_node(node);
}
}
return
0
;
}
/* recycle a node */
inline
int
interval_merge_tree_recycle_node
(
interval_merge_tree_node_t
*
node
)
{
if
(
node
&&
node
!=
&
interval_merge_tree_sentinel
)
{
node
->
left
=
NULL
;
node
->
right
=
NULL
;
/* destroy the key */
node
->
key
.
key
=
NULL
;
node
->
key
.
value
=
NULL
;
/* do not attempt to destroy the parent node ... just set to NULL */
node
->
parent
=
NULL
;
/* set the color to 0 */
node
->
color
=
0
;
/* set the max interval value */
node
->
max
=
0
;
/* destroy the interval */
//interval_merge_tree_destroy_interval(node->interval);
node
->
interval
.
start
=
0
;
node
->
interval
.
end
=
0
;
/* erase the pointers to, but do not destroy, the link list */
node
->
ll_head
=
NULL
;
node
->
ll_tail
=
NULL
;
}
return
0
;
}
/* destroy a node and it's children... but not the node parent */
int
interval_merge_tree_destroy_tree
(
interval_merge_tree_node_t
*
node
)
{
if
(
node
&&
node
!=
&
interval_merge_tree_sentinel
)
{
/* destroy the left node */
if
(
node
->
left
&&
node
->
left
!=
&
interval_merge_tree_sentinel
)
{
interval_merge_tree_destroy_tree
(
node
->
left
);
node
->
left
=
NULL
;
}
/* destory the right node */
if
(
node
->
right
&&
node
->
right
!=
&
interval_merge_tree_sentinel
)
{
interval_merge_tree_destroy_tree
(
node
->
right
);
node
->
right
=
NULL
;
}
/* destroy the key */
node
->
key
.
key
=
NULL
;
node
->
key
.
value
=
NULL
;
/* do not attempt to destroy the parent node ... just set to NULL */
node
->
parent
=
NULL
;
/* set the color to 0 */
node
->
color
=
0
;
/* set the max interval value */
node
->
max
=
0
;
/* destroy the interval */
node
->
interval
.
start
=
0
;
node
->
interval
.
end
=
0
;
/* cleanup the interval link list */
interval_merge_tree_interval_ll_destroy
(
node
->
ll_head
);
node
->
ll_head
=
NULL
;
node
->
ll_tail
=
NULL
;
/* destroy the node */
#if 0
if(node->node_pool)
{
interval_merge_tree_node_pool_free_node(node);
}
else
#endif
{
free
(
node
);
//interval_merge_tree_dealloc_node(node);
}
}
/* cleanup the mem pools */
//interval_merge_tree_destroy_ll_pool();
//interval_merge_tree_destroy_node_pool();
return
0
;
}
/* rotate the nodes to the left */
static
inline
int
interval_merge_tree_rotate_left
(
interval_merge_tree_node_t
**
root
,
interval_merge_tree_node_t
*
x
,
int
op
)
{
interval_merge_tree_node_t
*
y
=
x
->
right
;
x
->
right
=
y
->
left
;
if
(
y
->
left
&&
y
->
left
!=
&
interval_merge_tree_sentinel
)
{
y
->
left
->
parent
=
x
;
}
y
->
parent
=
x
->
parent
;
if
(
!
x
->
parent
||
x
->
parent
==
&
interval_merge_tree_sentinel
)
{
*
root
=
y
;
}
else
{
if
(
x
==
x
->
parent
->
left
)
{
x
->
parent
->
left
=
y
;
}
else
{
x
->
parent
->
right
=
y
;
}
}
y
->
left
=
x
;
x
->
parent
=
y
;
/* update the size based on the operation */
if
(
op
==
RB_TREE_INSERT
)
{
if
(
x
!=
&
interval_merge_tree_sentinel
&&
y
!=
&
interval_merge_tree_sentinel
)
{
y
->
size
=
x
->
size
;
assert
(
x
->
right
);
assert
(
x
->
left
);
x
->
size
=
x
->
left
->
size
+
x
->
right
->
size
+
1
;
}
}
else
{
if
(
x
!=
&
interval_merge_tree_sentinel
&&
y
!=
&
interval_merge_tree_sentinel
)
{
y
->
size
=
x
->
size
;
assert
(
x
->
right
);
assert
(
x
->
left
);
x
->
size
=
x
->
left
->
size
-
x
->
right
->
size
-
1
;
}
}
/* update the max interval */
y
->
max
=
interval_merge_tree_interval_max
(
y
);
x
->
max
=
interval_merge_tree_interval_max
(
x
);
return
0
;
}
/* rotate the nodes to the right */
static
inline
int
interval_merge_tree_rotate_right
(
interval_merge_tree_node_t
**
root
,
interval_merge_tree_node_t
*
y
,
int
op
)
{
interval_merge_tree_node_t
*
x
=
y
->
left
;
y
->
left
=
x
->
right
;
if
(
x
->
right
&&
x
->
right
!=
&
interval_merge_tree_sentinel
)
{
x
->
right
->
parent
=
y
;
}
x
->
parent
=
y
->
parent
;
if
(
!
y
->
parent
||
y
->
parent
==
&
interval_merge_tree_sentinel
)
{
*
root
=
x
;
}
else
{
if
(
y
==
y
->
parent
->
right
)
{
y
->
parent
->
right
=
x
;
}
else
{
y
->
parent
->
left
=
x
;
}
}
x
->
right
=
y
;
y
->
parent
=
x
;
/* update the size based on the operation */
if
(
op
==
RB_TREE_INSERT
)
{
if
(
x
!=
&
interval_merge_tree_sentinel
&&
y
!=
&
interval_merge_tree_sentinel
)
{
x
->
size
=
y
->
size
;
assert
(
y
->
left
);
assert
(
y
->
right
);
y
->
size
=
y
->
left
->
size
+
y
->
right
->
size
+
1
;
}
}
else
{
if
(
x
!=
&
interval_merge_tree_sentinel
&&
y
!=
&
interval_merge_tree_sentinel
)
{
x
->
size
=
y
->
size
;
assert
(
y
->
left
);
assert
(
y
->
right
);
y
->
size
=
y
->
left
->
size
-
y
->
right
->
size
-
1
;
}
}
/* update the max interval */
x
->
max
=
interval_merge_tree_interval_max
(
x
);
y
->
max
=
interval_merge_tree_interval_max
(
y
);
return
0
;
}
/* function to make sure the red-black tree properties are followed after inserts */
static
int
interval_merge_tree_insert_rules
(
interval_merge_tree_node_t
**
root
,
interval_merge_tree_node_t
*
node
)
{
interval_merge_tree_node_t
*
y
=
NULL
;
while
(
node
->
parent
->
color
==
RB_TREE_COLOR_RED
)
{
if
(
node
->
parent
==
node
->
parent
->
parent
->
left
)
{
y
=
node
->
parent
->
parent
->
right
;
if
(
y
->
color
==
RB_TREE_COLOR_RED
)
{
node
->
parent
->
color
=
RB_TREE_COLOR_BLACK
;
y
->
color
=
RB_TREE_COLOR_BLACK
;
node
->
parent
->
parent
->
color
=
RB_TREE_COLOR_RED
;
node
=
node
->
parent
->
parent
;
}
else
{
if
(
node
==
node
->
parent
->
right
)
{
node
=
node
->
parent
;
interval_merge_tree_rotate_left
(
root
,
node
,
RB_TREE_INSERT
);
}
node
->
parent
->
color
=
RB_TREE_COLOR_BLACK
;
node
->
parent
->
parent
->
color
=
RB_TREE_COLOR_RED
;
interval_merge_tree_rotate_right
(
root
,
node
->
parent
->
parent
,
RB_TREE_INSERT
);
}
}
else
{
y
=
node
->
parent
->
parent
->
left
;
if
(
y
->
color
==
RB_TREE_COLOR_RED
)
{
node
->
parent
->
color
=
RB_TREE_COLOR_BLACK
;
y
->
color
=
RB_TREE_COLOR_BLACK
;
node
->
parent
->
parent
->
color
=
RB_TREE_COLOR_RED
;
node
=
node
->
parent
->
parent
;
}
else
{
if
(
node
==
node
->
parent
->
left
)
{
node
=
node
->
parent
;
interval_merge_tree_rotate_right
(
root
,
node
,
RB_TREE_INSERT
);
}
node
->
parent
->
color
=
RB_TREE_COLOR_BLACK
;
node
->
parent
->
parent
->
color
=
RB_TREE_COLOR_RED
;
interval_merge_tree_rotate_left
(
root
,
node
->
parent
->
parent
,
RB_TREE_INSERT
);
}
}
}
(
*
root
)
->
color
=
RB_TREE_COLOR_BLACK
;
return
0
;
}
/* insert a node into the rb tree */
int
interval_merge_tree_insert
(
interval_merge_tree_node_t
**
node
,
interval_merge_tree_key_t
key
,
interval_merge_tree_node_t
**
root
)
{
interval_merge_tree_node_t
*
y
=
&
interval_merge_tree_sentinel
;
interval_merge_tree_node_t
*
x
=
*
root
;
/* if x is null, make it a sentinel */
if
(
!
x
)
{
x
=
&
interval_merge_tree_sentinel
;
}
/* if this is a new tree */
if
(
!*
root
)
{
/* create new memory pools */
//interval_merge_tree_create_ll_pool(INTERVAL_TREE_LL_POOL_SIZE);
//interval_merge_tree_create_node_pool(INTERVAL_TREE_NODE_POOL_SIZE);
}
if
(
!*
node
)
{
*
node
=
interval_merge_tree_create_node
();
/* update the size of the new node */
(
*
node
)
->
size
=
1
;
/* set the node max to the end of the interval */
(
*
node
)
->
max
=
(
*
node
)
->
interval
.
end
;
}
/* set the key */
(
*
node
)
->
key
=
key
;
while
(
x
!=
&
interval_merge_tree_sentinel
)
{
y
=
x
;
/* this is a duplicate... don't insert it */
if
(
*
(
size_t
*
)
key
.
key
==
*
(
size_t
*
)
x
->
key
.
key
)
{
return
1
;
}
else
{
/* update the size of the path */
x
->
size
+=
1
;
/* update the max variable for all nodes along the path */
if
((
*
node
)
->
max
>
x
->
max
)
{
x
->
max
=
(
*
node
)
->
max
;
}
if
(
*
(
size_t
*
)
key
.
key
<
*
(
size_t
*
)
x
->
key
.
key
)
{
x
=
x
->
left
;
}