C语言二叉树相关算法,C语言二叉树实现及搜索算法

本文利用C语言实现了简单的二叉树，每个结点只保存一个整数，并且，由于非常简单，树的根结点是确定的，而不是输入的。确定根结点以后，用户输入的每一个数都被insert(为什么不许使用CHA Ru啊！！！！！！！)到树中(-999表示停止)，利用深度优先的方法。建立好二  叉  树以后，分别利用深度优先(DFS)和广度优先(BFS)进行了遍历，输出结果。

需要注意的是，代码中btree表示binary tree，而不是普通意义上的平衡树(balance tree)(参见http://baike.baidu.com/view/363832.html)。list是一个简单的单向列表，用于广度优先遍历。

程序实现代码如下：

/**

* Author: Hegc Huang

* Data : 2009-5-5

*/

#include

/*basic size data*/

#define bsize sizeof(btree)

#define lsize sizeof(list)

/*basic struct*/

typedef struct _btree btree;

typedef struct _list list;

struct _btree

{

int data;

btree *left;

btree *right;

};

struct _list

{

btree *data;

list *next;

};

/*function prototype*/

btree *addchild(btree* root, int data);

void outputtree_dfs(btree* root);

void outputtree_bfs(btree* root);

void clearup(btree* root);

static void _outputtree_dfs(btree* root, int level);

static void _outputtree_bfs(list* first, list* last);

/**

* main function.

*/

int main(int argc, char *argv[])

{

int input = 0;

btree *root = (btree*)malloc(bsize);

memset(root, 0, bsize);

root->data = 77;

while (1)

{

printf("Input a integer, -999 to quit: ");

scanf("%d", &input);

fflush(stdin);

if (-999 == input)

{

break;

}

addchild(root, input);

}

printf("=========OUTPUT DFS========/n");

outputtree_dfs(root);

printf("=========OUTPUT BFS========/n");

outputtree_bfs(root);

/**/

clearup(root);

return 0;

}

/**

* add a child to the btree, using DFS.

*/

btree *addchild(btree* root, int data)

{

btree *nnode = NULL;

btree *left = root->left;

btree *right = root->right;

if ((data < root->data) && (left != NULL))

{

addchild(left, data);

}

else if ((data >= root->data) && (right != NULL))

{

addchild(right, data);

}

else if ((data < root->data) && (left == NULL))

{

nnode = (btree*)malloc(bsize);

memset(nnode, 0, bsize);

nnode->data = data;

root->left = nnode;

}

else if ((data >= root->data) && (right == NULL))

{

nnode = (btree*)malloc(bsize);

memset(nnode, 0, bsize);

nnode->data = data;

root->right = nnode;

}

return root;

}

/**

* output a btree using DFS.

*/

void outputtree_dfs(btree* root)

{

_outputtree_dfs(root, 0);

}

static void _outputtree_dfs(btree* root, int level)

{

int spaces = level;

if (root != NULL)

{

while (spaces-- > 0)

{

printf(" ");

}

printf("%d/n", root->data);

_outputtree_dfs(root->left, level + 1);

_outputtree_dfs(root->right, level + 1);

}

}

/**

* output a btree using BFS.

*/

void outputtree_bfs(btree* root)

{

list *node = NULL;

if (root != NULL)

{

node = (list*)malloc(lsize);

memset(node, 0, lsize);

node->data = root;

_outputtree_bfs(node, node);

}

}

static void _outputtree_bfs(list* first, list* last)

{

btree *root = NULL;

btree *left = NULL;

btree *right = NULL;

list *remove = first;

list *nlist = NULL;

remove = first;

if (remove != NULL)

{

root = remove->data;

printf("%d/n", root->data);

left = root->left;

right = root->right;

if (left != NULL)

{

nlist = (list*)malloc(lsize);

memset(nlist, 0, lsize);

nlist->data = left;

last->next = nlist;

last = nlist;

}

if (right != NULL)

{

nlist = (list*)malloc(lsize);

memset(nlist, 0, lsize);

nlist->data = right;

last->next = nlist;

last = nlist;

}

first = first->next;

remove->next = NULL;

free(remove);

_outputtree_bfs(first, last);

}

}

/**

* clear all the spaces btree uses.

*/

void clearup(btree* root)

{

if (root != NULL)

{

clearup(root->left);

clearup(root->right);

free(root);

}

}