二叉查找树

/* ZQU OJ 1377 二叉查找树 
    插入、查找（包含找最小数）、删除、遍历四大模块
*/
#include "stdafx.h"
#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <stack>
bool FLAG = false;
using namespace std;
typedef int key_type;
typedef struct SerachTree {
    key_type key;
    struct SerachTree *LChild, *RChild;
}SerachTree, *PNode;    //记住结构体这种typedef用法

/*INSER函数这里，因为需要以一个节点的地址作为实参，所以这里是没必要把Root作为全局变量来使用的*/
void INSERT(key_type insert_num, PNode *root) {     //用二级指针作为函数参数，用来修改从主函数传过来的Root指针指向的地址。
    //初始化一个临时节点
    PNode tmp = (PNode)malloc(sizeof(SerachTree));
    tmp->key = insert_num;
    tmp->LChild = tmp->RChild = NULL;       //tmp的作用是临时节点
    //当为空树时
    if ((*root) == NULL) {      //root是Root的地址，*root = x 用来修改Root的指向    //当然用Root也行，但是这里是通过函数传递的形式来完成的
        *root = tmp;
        return;
    }
    //树非空
    //root是二级指针，没有被分配一个SerachTree单位，所用*root指向Root,&（*root)->x 传入地址
    else {
        if (insert_num < (*root)->key)   //递归，以左儿子做新的根节点
            INSERT(insert_num, &(*root)->LChild);    
        if (insert_num >(*root)->key)  //递归，以右儿子做新的根节点
            INSERT(insert_num, &(*root)->RChild);
    }
    return;
}

PNode FIND(key_type find_num, PNode point) {        //这里没有涉及到对数据的修改，不需要二级指针
    //PNode res = NULL;
    //cout << "point:" << endl;
    // cout << point->key << ' ' << (point->LChild) << ' ' << point->RChild <<endl;
    //point = (PNode)malloc(sizeof(SerachTree));   //不能再分配内存（传入一个地址，这个地址指向已有的结构体，不需要开新内存）
    //cout << "@" << endl;
    /*
        这里要注意不能cout出空指针指向的单元，不然会引发segmentation fault，切记。
        可以cout空指针的地址，但不能cout"空指针指向的内容“。
    */
    if (point == NULL)        //节点为空时，返回一个NULL。这里作为递归基
        return NULL;
    if (find_num == point->key) {            
        //cout << "point->key=" << point->key << " point->LChild=" << point->LChild << " point->RChild=" << point->RChild <<endl;
        return point;        //如果找到了相等的元素，就返回这个节点的地址
    }
    else {
        //往左边走
        if (find_num < point->key /*&& point->LChild != NULL*/)        
            FIND(find_num, point->LChild);
        //往右边走
        else if (find_num > point->key /*&& point->RChild != NULL*/)
            FIND(find_num, point->RChild);
        else return NULL;
        /*判断左右儿子是否为空可不下*/
    }

    //return res;
}

//遍历二叉树，中序
void TRAVERSE(PNode N) {
    /*背代码，不解释。*/

    //如果该树为空
    //cout << "N->key=" << N->key <<endl;
    //N = (PNode)malloc(sizeof(SerachTree) );
    // cout << N->LChild << ' ' << N->RChild << endl;
    //FLAG = false;
    
    if (N != NULL) {            
        //if(N->LChild != NULL)
        //FLAG = true;
        TRAVERSE(N->LChild);
        // else return;
        cout << N->key << ' ';
        //if(N->RChild != NULL)
        TRAVERSE(N->RChild);
        //else return;
    }
    else return;
}
PNode FindMin(PNode T) {        //FindMin用来查找当前树中最小的元素，注意返回形式是一个PNode类型的指针，指向这个最小元素的地址
    if (T == NULL)
        return NULL;
    if (T->LChild == NULL)
        return T;
    else
        FindMin(T->LChild);
}
void DELETE(key_type delete_num, PNode *N) {    //设计到树中元素的修改，用二级指针
    PNode TmpCell;        //也是一个临时节点，需要的时候直接赋值用
    TmpCell = (PNode)malloc(sizeof(SerachTree));    //因为要往里面放入一个SerachTree类型数据，开辟新内存是必须的
    //空树
    if ((*N) == NULL)                        //如果这棵树是空的，那就无所谓删除了，直接返回
        return;

    /*下面这两个else if语句都是用来不断递归，直到定位到那个要被删除的元素为止*/
    else if (delete_num < (*N)->key) {        
        DELETE(delete_num, &(*N)->LChild);
    }
    else if (delete_num >(*N)->key) {
        DELETE(delete_num, &(*N)->RChild);
    }

    /*被删除的节点有一个儿子或者是叶节点，和它有两个儿子的删除方式是不一样的*/

    //如果被删除的节点有两个儿子（此时已近定位到那个被删除元素了）
    else if ((*N)->LChild && (*N)->RChild) {
        TmpCell = FindMin((*N)->RChild);    /*调用FindMin函数，找到右儿子树最小的节点
                                            为什么是右儿子？右儿子可以保证它所有的元素都能被插入到待会要被删除的节点，而不违反二叉树的定义*/
        (*N)->key = TmpCell->key;        //把找到的最小元素放进此时定位的那个节点
        DELETE((*N)->key, &(*N)->RChild);        //此时不断递归。以那个被找到右子树最小元素作为被删除的节点
                                                //为什么这么做？为了让这棵树能够符合二叉树的定义。
    }
    //一个儿子||叶节点
    //坑了我好久的亮点来了！
    else {
        TmpCell = *N;        //先把要删除的节点赋值给TmpCell
        if ((*N)->LChild == NULL/* && (*N)->RChild != NULL*/)
            *N = (*N)->RChild;        //如果左节点为空，则把右节点赋给*N
        else if ((*N)->RChild == NULL/* && (*N)->LChild != NULL*/) 
            (*N) = (*N)->LChild;    //如果右节点为空，则把左节点赋给*N

        /*
            else 一定要加！一定要！。因为如果进入前面的if语句意味着LChild是空的，不能在下面再赋值一次。
            至于后面被注释掉&&的内容，也是同样类型的错误
        */

        free(TmpCell);        //free释放TmpCell指向那个内存单元的内容（注意是指向的那个内存单元）
        //(*N )= NULL;
        TmpCell = NULL;        //释放后TmpCell还是存在的，定义为NULL防止野指针的出现
        return;
    }

}
int main()
{
    /*main函数的形式主要是为了过我们学校的OJ题*/
    string command;
    int command_num;
    PNode Root;     //创建根节点，此时为空
    Root = (SerachTree*)malloc(sizeof(SerachTree));     //为其分配内存，这一步必须要！
    Root = NULL;        //将根节点指向空，这一步必须要！
    //Root->LChild = Root->RChild = NULL;       这一步不能下，Root此时为空，不存在LChild和RChild，使用会引起段错误
    while (cin >> command) {
        //getchar();
        if (command != "traverse") {
            //cout << '!';
            cin >> command_num;
            //cout << command << endl;
            if (command == "insert")
                INSERT(command_num, &Root);     //调用插入函数(注意传入的是地址）
            //cout <<Root;
            if (command == "find") {
                string find_res[2] = { "yes", "no" };
                if (FIND(command_num, Root) != NULL) {
                    cout << find_res[0] << endl;
                }
                else cout << find_res[1] << endl;
            }
            if (command == "delete") {
                DELETE(command_num, &Root);
            }
        }
        else if (command == "traverse") {
            //cout << command <<endl;
            FLAG = false;
            TRAVERSE(Root);
            if (FLAG)
                cout << endl;
        }
    }
}