二叉树问题汇总（1）—基础问题

1、创建二叉搜索树

二叉搜索树是排序的二叉树，即左子树的值都不大于根结点，右子树的值都比根结点大。插入结点到一颗二叉搜索树可以使用递归或者非递归方法。使用递归方法代码简单，使用非递归则易于理解。

二叉搜索树BST定义：

struct node {
    int data;
    struct node* left;
    struct node* right;
};

二叉搜索树创建结点代码：

struct node* newNode(int data)
{
    struct node* nd = (struct node*)malloc(sizeof(struct node)); //分配空间
    nd->data = data;                  //设置data域
    nd->left = nd->right = NULL;      //初始化左右孩子结点为NULL
    return nd;
}

二叉搜索树插入结点代码1（递归，函数返回根结点）：

struct node* insert(struct node* root, int data)
{
    if (root == NULL) {  //二叉树为空，则创建结点直接返回。
        return newNode(data);
    } else {
        if (root->data >= data) { //如果根结点值大于或等于插入值，则插入结点到左子树。
            root->left = insert(root->left, data); 
        } else {                  //如果根结点值小于插入值，则插入结点到右子树。
            root->right = insert(root->right, data);
        }
        return root;    //返回根结点指针。
    }
}

二叉搜索树插入节点代码2（递归，函数无返回值）：

void insert2(struct node** rootRef, int data)          
{                                                      
    struct node* root = *rootRef;                      
    if (root == NULL) {                                
        *rootRef = newNode(data);                      
        return;                                        
    }                                                  
    if (root->data >= data)                            
        insert2(&(root->left), data);                  
    else                                               
        insert2(&(root->right), data);                 
}                                                      
                  

二叉搜索树插入节点代码3（非递归）：

void insert3(struct node** rootRef, int data)
{
    struct node* root = *rootRef;
    struct node* nd = newNode(data);
    if (root == NULL) {
        *rootRef = nd;
        return;
    }
    struct node* parent = NULL;
    struct node* current = root;
    while (current != NULL) {
        parent = current;   //parent跟踪结点插入，直到其孩子结点为NULL
        if (current->data >= data)
            current = current->left;
        else
            current = current->right;
    }
    if (parent->data >= data) //判断应该插入到左孩子还是右孩子
        parent->left = nd;
    else
        parent->right = nd;
}

创建二叉搜索树，包含3个结点：

//直接创建二叉树
struct node* build123a() {
struct node* root = newNode(2);
root->left = newNode(1);
root->right = newNode(3);
return(root);
}

//使用insert创建二叉搜索树
struct node* build123b() {
struct node* root = NULL;
root = insert(root, 2);
root = insert(root, 1);
root = insert(root, 3);
return(root);
}

2、二叉树结点数目（不需要是二叉搜索树）

//结点数目=左子树结点数目+右子树节点数目+1（根结点）
int size(struct node* root)
{
    if (root == NULL) return 0;
    return size(root->left) + size(root->right) + 1;
}

3、二叉树深度（根结点到最远叶结点距离，空树深度为0）

int maxDepth(struct node* root)
{
    if (root == NULL)
        return 0;
    else {
        int lDepth = maxDepth(root->left);  //递归获取左子树深度
        int rDepth = maxDepth(root->right); //获取右子树深度
        return lDepth>rDepth? lDepth+1: rDepth+1; //取较大值+1即为二叉树深度
    }
}

4、二叉搜索树最小值（最大值类似，查询右子树即可）

//根据二叉搜索树性质，直接往左子树迭代查询
int minValue(struct node* root)
{
    assert(root != NULL);
    struct node* current = root;
    while (current->left != NULL) {
        current = current->left;
    }
    return current->data;
}

//递归算法查询二叉搜索树最小值
int minValue(struct node* root)
{
    assert(root != NULL);
    if (root->left == NULL) return root->data;
    else return minValue(root->left);
}

5、查找二叉搜索树中是否存在某个值

/*查找二叉搜索树中是否存在值为target的结点*/
bool lookup(struct node* root, int target)
{
    if (root == NULL)
        return false;
    if (root->data == target)
        return true;
    else if (root->data > target)
        return lookup(root->left, target);
    else
        return lookup(root->right, target);
}