二叉树

一、二叉树简介

　　二叉树节点定义为：

struct TreeNode 
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

有时需要增加parent等其他信息。

二叉树的创建采用输入满二叉树数组的形式，例如 A = [1, -2, -3, 1, 3, 2, NIL, -1], 表示为：

　　　　　　　　1

　　　　　-2 　　　  -3

　　　　1　　3　   2

　　-1

由数组A构建一颗二叉树：

TreeNode* create_node(int x)
{
    if (x == NIL) /* means null */
        return NULL;
    else
        return new TreeNode(x);
}

TreeNode* btree_create(TreeNode *root, int va[], int n)
{
    TreeNode *nt = NULL, *pt = NULL;
    queue<TreeNode *> qtree;
    int i = 1;
    
    root = new TreeNode(va[0]);
    qtree.push(root);
    while (qtree.size() > 0)
    {
        pt = qtree.front();
        qtree.pop();
        if (pt == NULL)
            continue;        
        /* create left node */
        if (i >= n)
            break;
        pt->left = create_node(va[i]);
        i++;
        qtree.push(pt->left);        
        /* create right node */
        if (i >= n)
            break;
        pt->right = create_node(va[i]);
        i++;
        qtree.push(pt->right);
    }
    return root;
}

二、二叉树基本操作

1、min/max depth

int minDepth(TreeNode *root) 
    {
        if (root == NULL)
            return 0;
        int ml = minDepth(root->left);
        int mr = minDepth(root->right);
        
        if (ml == 0)        /* the min depth should contain leaf, not only the root node. */
            return (mr + 1);
        if (mr == 0)
            return (ml + 1);
            
        return min(ml, mr) + 1;
    }

int maxDepth(TreeNode *root) 
    {
        if (root == NULL)
            return 0;
            
        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
    }

2、二叉树广度优先/深度优先遍历

2.1、BFS

二叉树的bfs记为层次遍历，使用队列做辅助，如下：

a)将root放入队列queue

b)queue不为空，取出队列元素node，并访问

c)node左右节点入队，重复b

vector<int> btree_bfs(TreeNode* root)
{
    vector<int> tree_nodes;
    queue<TreeNode*> qtree;
    TreeNode* pt = root;
    
    if (pt == NULL)
        return tree_nodes;
        
    qtree.push(pt);
    while (!qtree.empty())
    {
        pt = qtree.front();
        qtree.pop();
        tree_nodes.push_back(pt->val);
        
        if (pt->left != NULL)
            qtree.push(pt->left);
        if (pt->right != NULL)
            qtree.push(pt->right);
    }
    
    return tree_nodes;
}

2.2 DFS

二叉树深度优先遍历，不妨以左节点优先，即左子树存在则先查询左节点，如下：

a) 当前节点不为空，访问之。并将右节点压栈，继续访问左节点。

b)节点为空，则从栈中取出node，继续a，直至访问完。

vector<int> btree_dfs(TreeNode* root)
{
    vector<int> tree_nodes;
    stack<TreeNode*> stree;
    TreeNode* pcur = root;
    
    if (pcur == NULL)
        return tree_nodes;
    
    while (!stree.empty() || (pcur != NULL))
    {
        if (pcur != NULL)
        {
            tree_nodes.push_back(pcur->val); // visit current
            if (pcur->right != NULL)
                stree.push(pcur->right);
            pcur = pcur->left;
        }
        else
        {
            pcur = stree.top();
            stree.pop();
        }
    }
    
    return tree_nodes;
}

3、pre/in/post order traverse

这三种方式遍历二叉树，递归遍历比较简单，非递归遍历则需要借助queue/stack。

3.1、preorder

void preorder(TreeNode *root, vector <int> &ret)
    {
        if (root == NULL)
            return;
        ret.push_back(root->val);
        preorder(root->left, ret);
        preorder(root->right, ret);
    }

preorder迭代形式和dfs完全一致。

3.2、inorder

void inorder(TreeNode *root, vector <int> &ret)
    {
        if (root == NULL)
            return;
        inorder(root->left, ret);
        ret.push_back(root->val);
        inorder(root->right, ret);
    }

迭代方式遍历:

a)当前节点不为空，则压栈并访问左子树。

b)否则，出栈并访问元素，再访问右子树，重复a。

vector<int> inorderTraversal(TreeNode *root) 
    {
        vector<int> tree_nodes;
        stack<TreeNode*> stree;
        TreeNode* pcur = root;
            
        while (!stree.empty() || (pcur != NULL))
        {
            if (pcur != NULL)
            {
                stree.push(pcur);
                pcur = pcur->left;  //left
            }
            else
            {
                pcur = stree.top(); 
                stree.pop();
                tree_nodes.push_back(pcur->val); 
                pcur = pcur->right; //right
            }
        }
        return tree_nodes;
    }

3.3 post order

void inorder(TreeNode *root, vector <int> &ret)
    {
        if (root == NULL)
            return;
        inorder(root->left, ret);
        inorder(root->right, ret);
        ret.push_back(root->val);
    }

后序遍历非递归形式：

a)当前节点pcur不为空，节点入栈，访问左节点

b)否则,获取栈顶节点peek，如果peek->right不为空且不是last_vist_node, pcur变为peek->right

c)否则last_vist_node为栈顶元素，并访问last_vist_node，继续a)

vector<int> postorderTraversal(TreeNode *root) 
    {
        vector<int> tree_nodes;
        stack<TreeNode *> stree;
        TreeNode *current = root, *last_visit_node = NULL, *peek_node = NULL;
        
        while (!stree.empty() || (current != NULL))
        {
            if (current != NULL)
            {
                stree.push(current);
                current = current->left;
            }
            else
            {
                peek_node = stree.top();
                if ((peek_node->right != NULL) && (peek_node->right != last_visit_node))
                { // peek's right child exists and it's not come from last child
                    current = peek_node->right;
                }
                else
                {
                    last_visit_node = peek_node;
                    stree.pop();
                    tree_nodes.push_back(last_visit_node->val);
                }
            }
        }
        
        return tree_nodes;
    }