C++ 实现二叉树的构造，插入，删除，遍历

#ifndef _TOU_H_
#define _TOU_H_
#include <iostream>
#include <cstdlib>
using namespace std;
#define datatype char
void visit(datatype item) 
{
    cout << item <<" ";
}

typedef 
struct node
{
    datatype data;
    struct node* leftchild;
    struct node* rightchild;
}bitreenode;
void initiate(bitreenode**root)//初始化二叉树
{
    *root = (bitreenode*)malloc(sizeof(bitreenode));
    (*root)->leftchild = NULL;
    (*root)->rightchild = NULL;
}

bitreenode* insertleftnode(bitreenode*curr, datatype x)//向该节点的左子树插入节点
{
    if (curr == NULL)
    {
        return NULL;
    }
    bitreenode* t = curr->leftchild;//保存原来节点的左子树节点
    bitreenode* s = (bitreenode*)malloc(sizeof(bitreenode));
    s->data = x;
    s->leftchild = t;//新插入节点的左子树为原节点的左子树
    s->rightchild = NULL;
    
    curr->leftchild = s;// 新节点成为curr的左子树
    return curr->leftchild;//返回新插入节点的指针
}

bitreenode* insertrightnode(bitreenode* curr, datatype x)
{
    if (curr == NULL)
    {
        return NULL;
    }
    bitreenode* t = curr->rightchild;
    bitreenode* s = (bitreenode*)malloc(sizeof(bitreenode));
    s->data = x;
    s->rightchild = t;//新插入节点的右子树为原节点的右子树
    s->leftchild = NULL;

    curr->rightchild = s;// 新节点成为curr的左子树
    return curr->rightchild;//返回新插入节点的指针
}

void destroy(bitreenode **root)
{
    if ((*root) != NULL && (*root)->leftchild != NULL)
        destroy(&(*root));
    if ((*root) != NULL && (*root)->rightchild != NULL)
        destroy(&(*root)->rightchild);
    free(*root);
}

bitreenode* deletelefttree(bitreenode* curr)
{
    if (curr == NULL || curr->leftchild == NULL) {
        return NULL;
    }
    destroy(&curr->leftchild);
    curr->leftchild = NULL;
    return curr;
}

bitreenode* deleterighttree(bitreenode* curr)
{
    if (curr == NULL || curr->rightchild == NULL)
        return NULL;
    destroy(&curr->rightchild);
    curr->rightchild = NULL;
    return curr;
}

void proorder(bitreenode* t, void visit(datatype item))//前序遍历
{
    if (t != NULL) {
        visit(t->data);
        proorder(t->leftchild, visit);
        proorder(t->rightchild, visit);
    }
}

void inorder(bitreenode* t, void visit(datatype item))//中序遍历
{
    if (t != NULL) {
        inorder(t->leftchild, visit);
        visit(t->data);
        inorder(t->rightchild, visit);
    }
}

void postorder(bitreenode* t,void visit(datatype item))//后序遍历
{
    if (t != NULL) {
        postorder(t->leftchild, visit);
        postorder(t->rightchild, visit);
        visit(t->data);
    }
}

void printibitree(bitreenode* br, int n)
{
    int i;
    if (br == NULL)return;//递归出口
    printibitree(br->rightchild, n + 1);//遍历打印右子树
    for (int i = 0; i < n; i++)cout << " ";
    if (n >= 0)
    {
        cout << " " << br->data << endl;
    }
    printibitree(br->leftchild, n + 1);
}
#endif

#include "tou.h"
#include <iostream>
using namespace std;
int main()
{
    bitreenode * root;
    initiate(&root);
    bitreenode* p, *pp;
    p = insertleftnode(root, 'a');
    p = insertleftnode(p, 'b');
    p = insertleftnode(p, 'd');
    p = insertrightnode(p, 'g');
    p = insertrightnode(root->leftchild, 'c');
    pp = p;
    insertrightnode(p, 'e');
    insertrightnode(pp, 'f');
    //proorder(root,visit(root->data));

    cout << "前序遍历:" ;
    proorder(root->leftchild, visit); cout << endl;
    cout << "中序遍历:" ;
    inorder(root->leftchild, visit); cout << endl;
    cout << "后序遍历:" ;
    postorder(root->leftchild, visit); cout << endl;
    

    system("pause");
    return 0;
}