c语言二叉树搜索函数,C语言实现二叉树的搜索及相关算法示例

本文实例讲述了C语言实现二叉树的搜索及相关算法。分享给大家供大家参考，具体如下：

二叉树(二叉查找树)是这样一类的树，父节点的左边孩子的key都小于它，右边孩子的key都大于它。

二叉树在查找和存储中通常能保持logn的查找、插入、删除，以及前驱、后继，最大值，最小值复杂度，并且不占用额外的空间。

这里演示二叉树的搜索及相关算法：

#include

#include

using namespace std;

class tree_node{

public:

int key;

tree_node *left;

tree_node *right;

int tag;

tree_node(){

key = 0;

left = right = NULL;

tag = 0;

}

~tree_node(){}

};

void visit(int value){

printf("%d\n", value);

}

// 插入

tree_node * insert_tree(tree_node *root, tree_node* node){

if (!node){

return root;

}

if (!root){

root = node;

return root;

}

tree_node * p = root;

while (p){

if (node->key < p->key){

if (p->left){

p = p->left;

}

else{

p->left = node;

break;

}

}

else{

if (p->right){

p = p->right;

}

else{

p->right = node;

break;

}

}

}

return root;

}

// 查询key所在node

tree_node* search_tree(tree_node* root, int key){

tree_node * p = root;

while (p){

if (key < p->key){

p = p->left;

}

else if (key > p->key){

p = p->right;

}

else{

return p;

}

}

return NULL;

}

// 创建树

tree_node* create_tree(tree_node *t, int n){

tree_node * root = t;

for (int i = 1; i

insert_tree(root, t + i);

}

return root;

}

// 节点前驱

tree_node* tree_pre(tree_node* root){

if (!root->left){ return NULL; }

tree_node* p = root->left;

while (p->right){

p = p->right;

}

return p;

}

// 节点后继

tree_node* tree_suc(tree_node* root){

if (!root->right){ return NULL; }

tree_node* p = root->right;

while (p->left){

p = p->left;

}

return p;

}

// 中序遍历

void tree_walk_mid(tree_node *root){

if (!root){ return; }

tree_walk_mid(root->left);

visit(root->key);

tree_walk_mid(root->right);

}

// 中序遍历非递归

void tree_walk_mid_norecursive(tree_node *root){

if (!root){ return; }

tree_node* p = root;

stack s;

while (!s.empty() || p){

while (p){

s.push(p);

p = p->left;

}

if (!s.empty()){

p = s.top();

s.pop();

visit(p->key);

p = p->right;

}

}

}

// 前序遍历

void tree_walk_pre(tree_node *root){

if (!root){ return; }

visit(root->key);

tree_walk_pre(root->left);

tree_walk_pre(root->right);

}

// 前序遍历非递归

void tree_walk_pre_norecursive(tree_node *root){

if (!root){ return; }

stack s;

tree_node* p = root;

s.push(p);

while (!s.empty()){

tree_node *node = s.top();

s.pop();

visit(node->key);

if (node->right){

s.push(node->right);

}

if (node->left){

s.push(node->left);

}

}

}

// 后序遍历

void tree_walk_post(tree_node *root){

if (!root){ return; }

tree_walk_post(root->left);

tree_walk_post(root->right);

visit(root->key);

}

// 后序遍历非递归

void tree_walk_post_norecursive(tree_node *root){

if (!root){ return; }

stack s;

s.push(root);

while (!s.empty()){

tree_node * node = s.top();

if (node->tag != 1){

node->tag = 1;

if (node->right){

s.push(node->right);

}

if (node->left){

s.push(node->left);

}

}

else{

visit(node->key);

s.pop();

}

}

}

// 层级遍历非递归

void tree_walk_level_norecursive(tree_node *root){

if (!root){ return; }

queue q;

tree_node* p = root;

q.push(p);

while (!q.empty()){

tree_node *node = q.front();

q.pop();

visit(node->key);

if (node->left){

q.push(node->left);

}

if (node->right){

q.push(node->right);

}

}

}

// 拷贝树

tree_node * tree_copy(tree_node *root){

if (!root){ return NULL; }

tree_node* newroot = new tree_node();

newroot->key = root->key;

newroot->left = tree_copy(root->left);

newroot->right = tree_copy(root->right);

return newroot;

}

// 拷贝树

tree_node * tree_copy_norecursive(tree_node *root){

if (!root){ return NULL; }

tree_node* newroot = new tree_node();

newroot->key = root->key;

stack s1, s2;

tree_node *p1 = root;

tree_node *p2 = newroot;

s1.push(root);

s2.push(newroot);

while (!s1.empty()){

tree_node* node1 = s1.top();

s1.pop();

tree_node* node2 = s2.top();

s2.pop();

if (node1->right){

s1.push(node1->right);

tree_node* newnode = new tree_node();

newnode->key = node1->right->key;

node2->right = newnode;

s2.push(newnode);

}

if (node1->left){

s1.push(node1->left);

tree_node* newnode = new tree_node();

newnode->key = node1->left->key;

node2->left = newnode;

s2.push(newnode);

}

}

return newroot;

}

int main(){

tree_node T[6];

for (int i = 0; i < 6; i++){

T[i].key = i*2;

}

T[0].key = 5;

tree_node* root = create_tree(T, 6);

//tree_walk_mid(root);

//tree_walk_mid_norecursive(root);

//tree_walk_pre(root);

//tree_walk_pre_norecursive(root);

//tree_walk_post(root);

//tree_walk_post_norecursive(root);

//tree_walk_level_norecursive(root);

visit(search_tree(root, 6)->key);

visit(tree_pre(root)->key);

visit(tree_suc(root)->key);

//tree_node* newroot = tree_copy_norecursive(root);

//tree_walk_mid(newroot);

return 0;

}

希望本文所述对大家C语言程序设计有所帮助。