1. 源代码
ia_binarytree.h
#ifndef __IA_BINARY_TREE_H__
#define __IA_BINARY_TREE_H__
#include <common.h>
typedef struct _binary_tree_node_t {
int key;
struct _binary_tree_node_t *p;
struct _binary_tree_node_t *left;
struct _binary_tree_node_t *right;
} binary_tree_node_t;
typedef struct _binary_tree_t {
binary_tree_node_t *root;
} binary_tree_t;
void ia_binary_tree_inorder_walk(binary_tree_node_t *x, FILE *f);
binary_tree_node_t *ia_binary_tree_search(binary_tree_node_t *x, int k);
binary_tree_node_t *ia_binary_tree_iterative_search(binary_tree_node_t *x, int k);
//x must not be NIL(NULL)
binary_tree_node_t *ia_binary_tree_minimum(binary_tree_node_t *x);
//x must not be NIL(NULL)
binary_tree_node_t *ia_binary_tree_maximum(binary_tree_node_t *x);
binary_tree_node_t *ia_binary_tree_successor(binary_tree_node_t *x);
binary_tree_node_t *ia_binary_tree_predecessor(binary_tree_node_t *x);
void ia_binary_tree_insert(binary_tree_t *T, binary_tree_node_t *z);
void ia_binary_tree_delete(binary_tree_t *T, binary_tree_node_t *z);
#endif /* __IA_BINARY_TREE_H__ */
ia_binarytree.c
#include <ia_binarytree.h>
void ia_binary_tree_inorder_walk(binary_tree_node_t *x, FILE *f)
{
const char* s_1 = "child {\nnode [arn_n] {";
const char* s_1_space = "child {\nnode [arn_x] {";
const char* s_2 = "}\n";
//const char* s_3 = "}\r\n";
char s_v[20];
if (x != NIL) {
if (f == NULL) {
ia_binary_tree_inorder_walk(x->left, f);
TRACE(" %d", x->key);
ia_binary_tree_inorder_walk(x->right, f);
} else {
sprintf_s(s_v, sizeof(s_v), "%d", x->key);
fputs(s_1, f);
fputs(s_v, f);
fputs(s_2, f);
//print children
ia_binary_tree_inorder_walk(x->left, f);
ia_binary_tree_inorder_walk(x->right, f);
fputs(s_2, f);
}
} else {
if (f != NULL) {
fputs(s_1_space, f);
fputs(s_2, f);
fputs(s_2, f);
}
}
}
binary_tree_node_t *ia_binary_tree_search(binary_tree_node_t *x, int k)
{
if (x == NIL || k == x->key) {
return x;
}
if (k < x->key) {
return ia_binary_tree_search(x->left, k);
} else {
return ia_binary_tree_search(x->right, k);
}
}
binary_tree_node_t *ia_binary_tree_iterative_search(binary_tree_node_t *x, int k)
{
while (x != NIL && k != x->key) {
x = (k < x->key)?x->left:x->right;
}
return x;
}
//x must not be NIL(NULL)
binary_tree_node_t *ia_binary_tree_minimum(binary_tree_node_t *x)
{
while (x->left != NIL) {
x = x->left;
}
return x;
}
//x must not be NIL(NULL)
binary_tree_node_t *ia_binary_tree_maximum(binary_tree_node_t *x)
{
while (x->right != NIL) {
x = x->right;
}
return x;
}
binary_tree_node_t *ia_binary_tree_successor(binary_tree_node_t *x)
{
binary_tree_node_t *y = NIL;
if (x->right != NIL) {
return ia_binary_tree_minimum(x->right);
}
y = x->p;
while (y != NIL && x == y->right) {
x = y;
y = y->p;
}
return y;
}
binary_tree_node_t *ia_binary_tree_predecessor(binary_tree_node_t *x)
{
binary_tree_node_t *y = NIL;
if (x->left != NIL) {
return ia_binary_tree_maximum(x->left);
}
y = x->p;
while (y != NIL && x == y->left) {
x = y;
y = y->p;
}
return y;
}
void ia_binary_tree_insert(binary_tree_t *T, binary_tree_node_t *z)
{
binary_tree_node_t *x = T->root;
binary_tree_node_t *y = NIL;
while (x != NIL) {
y = x;
if (z->key < x->key) {
x = x->left;
} else {
x = x->right;
}
}
z->p = y;
if (y == NIL) {
T->root = z; //tree T is empty
} else if (z->key < y->key) {
y->left = z;
} else {
y->right = z;
}
}
static void ia_binary_tree_transplant(
binary_tree_t *T,
binary_tree_node_t *u,
binary_tree_node_t *v)
{
if (u->p == NIL) {
T->root = v;
} else if (u == u->p->left) {
u->p->left = v;
} else {
u->p->right = v;
}
if (v != NIL) {
v->p = u->p;
}
}
void ia_binary_tree_delete(binary_tree_t *T, binary_tree_node_t *z)
{
binary_tree_node_t *y = NIL;
if (z->left == NIL) {
ia_binary_tree_transplant(T, z, z->right);
} else if (z->right == NIL) {
ia_binary_tree_transplant(T, z, z->left);
} else {
y = ia_binary_tree_minimum(z->right);
if (y->p != z) {
ia_binary_tree_transplant(T, y,y->right);
y->right = z->right;
z->right->p = y;
}
ia_binary_tree_transplant(T, z, y);
y->left = z->left;
y->left->p = y;
}
}
test.c
#include <ia_include.h>
#define TEST_IASTACK_SIZE 10
#define TEST_IAQUEUE_SIZE 10
#define TEST_IABINARYTREE_NODES 20
void main()
{
int i = 0;
/*
iastack_t test_stack;
iaqueue_t test_queue;
TRACE("=========Test iastack=========\n");
iastack_init(&test_stack, TEST_IASTACK_SIZE);
for (i = 0; i < (TEST_IASTACK_SIZE); ++i) {
iastack_push(&test_stack, i);
}
for (i = 0; i < (TEST_IASTACK_SIZE); ++i) {
TRACE("%d\t", iastack_pop(&test_stack));
}
TRACE("\n");
iastack_free(&test_stack);
TRACE("=========Test iaqueque=========\n");
iaqueue_init(&test_queue, TEST_IAQUEUE_SIZE);
for (i = 0; i < (8); ++i) {
iaqueue_enqueue(&test_queue, i);
}
for (i = 0; i < (5); ++i) {
TRACE("%d\t", iaqueue_dequeue(&test_queue));
}
TRACE("\n");
for (i = 0; i < (7); ++i) {
iaqueue_enqueue(&test_queue, i);
}
for (i = 0; i < (5); ++i) {
TRACE("%d\t", iaqueue_dequeue(&test_queue));
}
TRACE("\n");
iaqueue_free(&test_queue);
*/
FILE *f_out = NULL;
binary_tree_t T;
binary_tree_node_t t_nodes[TEST_IABINARYTREE_NODES];
int nodes_v[TEST_IABINARYTREE_NODES] =
{ 5, 3, 4, 8, 1, 20, 33, 30, 34, 28,
8, 33, 11, 24, 11, 10, 12, 18, 22, 23 };
T.root = NIL;
memset(t_nodes, 0, sizeof(t_nodes));
for (i = 0; i < sizeof(t_nodes)/sizeof(binary_tree_node_t); ++i) {
t_nodes[i].key = nodes_v[i];
ia_binary_tree_insert(&T, &t_nodes[i]);
}
f_out = fopen("out.txt", "w+");
if (f_out == NULL) {
TRACE("Fail to create file out.txt\nQuit!");
goto l_exit;
}
ia_binary_tree_inorder_walk(T.root, NULL);
//ia_binary_tree_inorder_walk(T.root, f_out);
printf("\n\n");
ia_binary_tree_delete(&T, &t_nodes[5]);
ia_binary_tree_inorder_walk(T.root, NULL);
ia_binary_tree_inorder_walk(T.root, f_out);
l_exit:
if (f_out != NULL) {
fclose(f_out);
}
printf("\n\n");
system("pause");
}
2.输出
3. Tikz画图脚本
请参考:http://www.texample.net/tikz/examples/red-black-tree/
\tikzset{
treenode/.style = {align=center, inner sep=0pt, text centered,
font=\sffamily},
arn_b/.style = {treenode, circle, white, font=\sffamily\bfseries, draw=black,
fill=black, text width=2em},% arbre rouge noir, noeud noir
arn_r/.style = {treenode, circle, red, draw=red,
text width=1.5em, very thick},% arbre rouge noir, noeud rouge
arn_x/.style = {treenode, rectangle, draw=black,
minimum width=0.5em, minimum height=0.5em},% arbre rouge noir, nil
arn_n/.style = {treenode, circle, black, draw=black,
text width=2em, very thick}
}
\begin{document}
\begin{tikzpicture} [->,>=stealth',level/.style={sibling distance = 20cm/#1,
level distance = 1.5cm}]
\node [arn_n] {root}
child {
node [arn_n] {5}
child {
node [arn_n] {3}
child {
node [arn_n] {1}
child {
node [arn_x] {}
}
child {
node [arn_x] {}
}
}
child {
node [arn_n] {4}
child {
node [arn_x] {}
}
child {
node [arn_x] {}
}
}
}
child {
node [arn_n] {8}
child {
node [arn_x] {}
}
child {
node [arn_n] {22}
child {
node [arn_n] {8}
child {
node [arn_x] {}
}
child {
node [arn_n] {11}
child {
node [arn_n] {10}
child {
node [arn_x] {}
}
child {
node [arn_x] {}
}
}
child {
node [arn_n] {11}
child {
node [arn_x] {}
}
child {
node [arn_n] {12}
child {
node [arn_x] {}
}
child {
node [arn_n] {18}
child {
node [arn_x] {}
}
child {
node [arn_x] {}
}
}
}
}
}
}
child {
node [arn_n] {33}
child {
node [arn_n] {30}
child {
node [arn_n] {28}
child {
node [arn_n] {24}
child {
node [arn_n] {23}
child {
node [arn_x] {}
}
child {
node [arn_x] {}
}
}
child {
node [arn_x] {}
}
}
child {
node [arn_x] {}
}
}
child {
node [arn_x] {}
}
}
child {
node [arn_n] {34}
child {
node [arn_n] {33}
child {
node [arn_x] {}
}
child {
node [arn_x] {}
}
}
child {
node [arn_x] {}
}
}
}
}
}
}
;
\end{tikzpicture}