二叉查找树(BST)---创建 清空 遍历

#include  < iostream >
#include  < queue >
#include  < stdlib.h >
using   namespace  std;

// 定义树结构
typedef  struct  tree_node_tag ... {
    int value;
    struct tree_node_tag *left;
    struct tree_node_tag *right;
}  TreeNode;

// 通过父节点插入建立二叉树
void  insert_node(TreeNode  * parent, TreeNode  * node)
... {
    if (!parent)    //插入时必须确保父节点不为空
    ...{
        cout << "parent not null" << endl;
        return;
    }
    if (node->value < parent->value) ...{    //比父节点小则插入左子树
        if (parent->left != NULL) ...{        //如果左子树还有节点，则继续
            insert_node(parent->left, node);
        }
        else
        ...{                                //否则直接插入
            parent->left = node;
            return;
        }
    }
    else...{
        if (parent->right != NULL) ...{
            insert_node(parent->right, node);
        }
        else
        ...{
            parent->right = node;
            return;
        }
    }
}
// 分配节点空间
int   new_node(TreeNode  ** node)
... {
    *node=(TreeNode*)malloc(sizeof(TreeNode));
    if (*node == NULL) ...{
        return -1;
    }
    (*node)->left=(*node)->right = NULL;
    (*node)->value = 0;
    return 0;
}
// 创建二叉树
void  create_tree(TreeNode  ** head)
... {
    TreeNode *p=NULL;
    int value;
    int ret;
    TreeNode *node= NULL;
    
    ret = new_node(&node);
    if ( ret == -1) ...{
        cout << "new_node error" << endl;
        return;
    }
    //指向头节点
    p=node;
    *head=p;
    cin >> value;
    node->value = value;
    //插入其它节点,以-1为结束标志
    while (1) 
    ...{
        cin >> value;
        if (value == -1)    break;
        ret = new_node(&node);
        if ( ret == -1) ...{
            cout << "new_node error" << endl;
            return;
        }
        node->value = value;
        insert_node(p,node);
    }
}

// 输出节点
void  print(TreeNode  * t)
... {
    cout << t->value << " ";
}

void  del_node(TreeNode  * current)
... {
    free(current);
    current = NULL;
}

void  preorder(TreeNode  * t,  void  ( * pred)(TreeNode  * ))
... {
    if (t) ...{
        pred(t);
        preorder(t->left, pred);
        preorder(t->right, pred);
    }
}

void  inorder(TreeNode  * t,  void  ( * pred)(TreeNode  * ))
... {
    if (t) ...{
        inorder(t->left, pred);
        pred(t);
        inorder(t->right, pred);
    }
}

void  postorder(TreeNode  * t,  void  ( * pred)(TreeNode  * ))
... {
    if (t) ...{
        postorder(t->left, pred);
        postorder(t->right, pred);
        pred(t);
    }
}
void  hierarchy(TreeNode  * t,  void  ( * pred)(TreeNode  * ))
... {
    queue<TreeNode *> que;
    TreeNode *pTmp = NULL;
    que.push(t);

    while (!que.empty()) ...{
        pTmp = que.front();
        if (pTmp->left != NULL) ...{
            que.push(pTmp->left);
        }
        if (pTmp->right != NULL) ...{
            que.push(pTmp->right);
        }
        pred(pTmp);
        que.pop();        
    }
}

void  visit(TreeNode  * t,  void  ( * pred1)(TreeNode  * ),  void ( * pred)(TreeNode  * ,  void  ( * )(TreeNode  * )))
... {
    if (t) ...{
        pred(t, pred1);
    }
}
void  clear(TreeNode  ** head)
... {
    //后序遍历清空
    visit(*head, del_node, postorder);
    *head = NULL;
}
void  main( void )
... {
    TreeNode *head=NULL;
    //空头节点
    cout << "建立二叉树，节点数据为整型，以-1为输入结束" <<endl;
    create_tree(&head);
    
    //前序遍历
    cout << "前序遍历" << endl;
    visit(head, print, preorder);
    cout << endl;

    cout << "中序遍历" << endl;
    visit(head, print, inorder);
    cout << endl;

    cout << "后序遍历" << endl;
    visit(head, print, postorder);
    cout << endl;

    cout << "层次遍历" << endl;
    visit(head, print,hierarchy);
    cout << endl;

    cout << "清空二叉树" << endl;
    clear(&head);
    visit(head, print, inorder);
    cout << endl;
    
    getchar();
}

修正clear函数

void clear(TreeNode *&t)
{
 //后序遍历清空
// visit(head, del_node, postorder);
 if (t != NULL) {
  clear(t->left);
  clear(t->right);
  free(t);
  t = NULL;
 }
}

测试

建立二叉树，节点数据为整型，以-1为输入结束
5
3
8
6
1
-1
前序遍历
5 3 1 8 6
中序遍历
1 3 5 6 8
后序遍历
1 3 6 8 5
层次遍历
5 3 8 1 6
清空二叉树