程序代码：

#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include<conio.h>
#define MAXNODE  1024

struct node  
{
    int value;

    struct node* lchild;
    struct node* rchild;
}BiTree,*PBiTree;
typedef int ElemType;
typedef int KeyType; 
typedef struct Node
{
    ElemType elem;/*数据元素字段*/
    struct Node *lchild,*rchild;/*左右指针字段*/
}NodeType;/*二叉树结点类型*/

typedef struct node NODE;
typedef struct node* PNODE;

void menu();                          //菜单

int my_scanf();                       //输入函数

void new_node(PNODE* n,int value);    //创造一个新节点

void free_node(PNODE* n);             //释放节点

void free_tree(PNODE* n);             //释放二叉树

PNODE find_node(PNODE n,int value);   //查找节点（递归） 
int SearchElem(NodeType *t,NodeType **p,NodeType **q,KeyType x)//查找结点（迭代） 

void insert_node(PNODE* n,int value); //插入节点 

void deletenode(PNODE* n);             //删除节点

void delete_node(PNODE* n,int value);  

void pre_order_traversal(PNODE n);     //前序遍历

void in_order_traversal(PNODE n);      //中序遍历

void NRPre_order_traversal(PNODE n);    //非递归前序遍历 

void NRIn_order_traversal(PNODE n);         //非递归中序遍历

int main()
{
    int option=0;

    PNODE tree=NULL;
    PNODE node=NULL;

    while (1)
    {
        system("cls");

        menu();

        option=my_scanf();

        puts("---------------------------------");

    if (option<0||option>8)
    {    
         fprintf(stderr,"invalid option\n");
         system("pause");

         continue ;
    }


        switch (option)
        {
            case 0:

                exit(0);

            case 1:

                printf("输入要插入的数字:");

                option=my_scanf();

                puts("\n");

                insert_node(&tree,option);

                break;

            case 2:

                printf("输入要删除的数字:");

                option=my_scanf();

                puts("\n");

                delete_node(&tree,option);

                break;

            case 3:

                printf("输入要查找的数字（递归）");

                option=my_scanf();

                puts("\n");
                
                case 4:

                printf("输入要查找的数字（迭代）");

                option=my_scanf();

                puts("\n");
                

                node=find_node(tree,option);

                if (node!=NULL)
                    puts("查找成功\n");
                else
                    puts("没有这个数字\n");

                break;

            case 5:

                puts("前序遍历:");

                pre_order_traversal(tree);

                puts("\n");

                break;


           

            case 6:

                puts("中序遍历:");

                in_order_traversal(tree);

                puts("\n");

                break;

            case 7:

                puts("非递归前序遍历:");

               NRPre_order_traversal(tree);

                puts("\n");

                break;
                
                
                case 8:

                puts("非递归中序遍历:");

               NRIn_order_traversal(tree);

                puts("\n");

                break; 

           

        }

        system("pause");

    }

    return 0;
}

void menu()
{
    puts("---------------------------------");
    puts("0 退出");
    puts("1 插入数字");
    puts("2 删除数字");
    puts("3 查找数字（递归）");
    puts("4 查找数字（迭代）");
    puts("5 前序遍历");
    puts("6 中序遍历");
    puts("7 非递归前序遍历");
    puts("8 非递归中序遍历");
   
    puts("---------------------------------");
    printf("输入你的选择:");
}

int my_scanf()
{
    char buf[50]={0};

    int option=0;

    fgets(buf,sizeof (buf),stdin);
    sscanf(buf,"%i",&option);

    return option;
}

void new_node(PNODE* n,int value)    //创建节点
{
    *n=(PNODE)malloc(sizeof (NODE));//开辟一个节点

    if (*n!=NULL)
    {
        (*n)->value=value;   //赋值
        (*n)->lchild=NULL;     //初始化
        (*n)->rchild=NULL;   
    }
}

void free_node(PNODE* n)      //释放节点
{
    if ((*n)!=NULL)
        free(*n);

    *n=NULL;
}
  
void free_tree(PNODE* n)      //释放二叉树
{
    if (*n==NULL)  
        return ;

    if ((*n)->lchild!=NULL)  
        free_tree(&(*n)->lchild);   //进行递归释放左节点

    if ((*n)->rchild!=NULL)
        free_tree(&(*n)->rchild);  //进行递归释放右节点

    free_node(n);                 //释放节点

    *n=NULL;
}

PNODE find_node(PNODE n,int value) //查找节点
{
    if (n==NULL)                          //如果节点为空则返回
        return NULL;

    if (n->value==value)                  //如果找到数据,则返回该数据的指针
        return n;
  
    if (value<=n->value)                  
         return find_node(n->lchild,value);

    return find_node(n->rchild,value); 

}

int SearchElem(NodeType *t,NodeType **p,NodeType **q,KeyType x)
{
    /*在二叉搜索树t上查找关键码为x的元素，若找到，返回1，且q指向该结点，p指向其父结点；*/
    /*否则，返回0，且p指向查找失败的最后一个结点*/
    int flag=0;
    *q=t;
    while(*q)/*从根节点开始查找*/
    {
        if(x>(*q)->elem.key)  /*x大于当前结点*q的元素关键码*/
        {
        *p=*q;*q=(*q)->rchild; /*将当前结点*q的右孩子置为新根*/
    }
    else
    {
        if(x<(*q)->elem.key)/*x小于当前结点*q的元素关键码*/
        {
            *p=*q;*q=(*q)->lchild;/*将当前结点*q的左孩子置为新根*/
        }
        else{
            flag=1;break;/*查找成功，返回*/
        }
        /*while*/
        return flag;
    }
}

void insert_node(PNODE* n,int value) //插入节点
{
    if (*n==NULL)   //找到插入的位置
        new_node(n,value);       
    else if (value==(*n)->value)
        return ;
    else if (value<(*n)->value)
        insert_node(&((*n)->lchild),value);
    else
        insert_node(&((*n)->rchild),value);

}



void deletenode(PNODE *n)    //删除节点
{
    PNODE tmp=NULL;

    if ((*n)==NULL)
        return ;

    if ((*n)->rchild==NULL)
    {
        tmp=*n;
        *n=(*n)->lchild;

        free_node(n);
    }
    else if ((*n)->lchild==NULL)
    {
        tmp=*n;
        *n=(*n)->rchild;

        free_node(n);
    }
    else 
    {
        for (tmp=(*n)->rchild;tmp->lchild!=NULL;tmp=tmp->lchild);

        tmp->lchild=(*n)->lchild;

        tmp=(*n);

        *n=(*n)->rchild;

        free_node(&tmp);
    }
}


void Visit(PBiTree n);         //访问节点数据
{
    printf("%4d",n->data);
}

void delete_node(PNODE* n,int value)
{
    PNODE node=NULL;

    if ((*n)==NULL)
        return ;

    node=find_node(*n,value);

    if ((*n)->value==value)
        deletenode(n);
    else if (value<(*n)->value)
        delete_node(&((*n)->lchild),value);
    else 
        delete_node(&((*n)->rchild),value);
}

void pre_order_traversal(PNODE n)      //前序遍历
{
    if (n!=NULL)
    {
        printf("%i ",n->value);

        pre_order_traversal(n->lchild);
        pre_order_traversal(n->rchild);
    }
}

void in_order_traversal(PNODE n)       //中序遍历
{
    if (n!=NULL)
    {
        in_order_traversal(n->lchild);

        printf("%i ",n->value);

        in_order_traversal(n->rchild);
        
    }
}

void NRPre_order_traversal(PNODE n)  //非递归先序遍历(迭代实现先序遍历)
{
    PBiTree stack[MAXNODE],t;
    int top;
    if(n==NULL)
    return;
    top=0;
    t=n;
    while(!(t==NULL&&top==0))
    {
        while(t!=NULL)
        {
            Visit(t);
            if(top<MAXNODE-1)
            {
                stack[top]=t;
                top++;
            }
            else {
                printf("栈溢出");
            
            return; 
        }
        t=t->lchild;
        
    }
    if(top<=0)
    return;
    else{
        top--;
        t=stack[top];
        t=t->rchild;
    }
}
}
void NRIn_order_traversal(PNODE n) //非递归中序遍历（迭代中序遍历） 

    PBiTree stack[MAXNODE],t;
    int top;
    if(n==NULL)
    return;
    top=0;
    t=n;
    while(!(t==NULL&&top==0))
    {
        while(t!=NULL)
        {
            Visit(t);
            if(top<MAXNODE-1)
            {
                stack[top]=t;
                top++;
            }
            else {
                printf("栈溢出");
            
            return; 
        }
        t=t->lchild;
        
    }
    if(top<=0)
    return;
    else{
        top--;
        t=stack[top];
        t=t->rchild;
    }
}
}