二叉树遍历DFS BFS

（DFS）二叉树深度搜索的三种遍历方式：先序遍历、中序遍历和后序遍历的递归和迭代

递归实现：先序遍历、中序遍历和后序遍历

先序遍历：

void preorderTra(TreeNode* root, vector<int>& nodes) {
    if (root == nullptr) {
        return;
    }
    node.push_back(root->val);
    preorderTra(root->left, nodes);
    preorderTra(root->right, nodes);
}

中序遍历

void inorderTra(TreeNode* root, vector<int>& nodes) {
    if (root == nullptr) {
        return;
    }
    inorderTra(root->left, nodes);
    node.push_back(root->val);
    inorderTra(root->right, nodes);
}

后序遍历

void postorderTra(TreeNode* root, vector<int>& nodes) {
    if (root == nullptr) {
        return;
    }
    postorderTra(root->left, nodes);
    postorderTra(root->right, nodes);
    node.push_back(root->val);
}

迭代实现：先序遍历、中序遍历和后序遍历

先序遍历：

void preorderTra(TreeNode* root, vector<int>& nodes) {
    stack<TreeNode*> sta;
    TreeNode* cur = root;
    while (cur != nullptr || !sta.empty()) {
        while (cur != nullptr) {
            //处理根
            nodes.push_back(cur->val);
            //入栈
            sta.push(cur);
            //向左走
            cur = cur->left;
        }
        //出栈
        cur = sta.top();
        sta.pop();
        //向右走
        cur = cur->right;
    }
}

中序遍历

void inorderTra(TreeNode* root, vector<int>& nodes) {
    stack<TreeNode*> sta;
    TreeNode* cur = root;
    while (cur != nullptr || !sta.empty()) {
        while (cur != nullptr) {
            //入栈
            sta.push(cur);
            //向左走
            cur = cur->left;
        }
        //出栈
        cur = sta.top();
        sta.pop();
        //处理根节点
        nodes.push_back(cur->val);
        //向右走
        cur = cur->right;
    }
}

后序遍历

void postorderTra(TreeNode* root, vector<int>& nodes) {
    stack<TreeNode*> sta;
    TreeNode* cur = root;
    TreeNode* prev = nullptr;//标记作用
    while (cur != nullptr || !sta.empty()) {
        while (cur != nullptr) {
            sta.push(cur);
            cur = cur->left;
        }
        //判断当前节点是否有右
        //有 处理
        cur = sta.top();
        if (cur->right != nullptr && cur->right != prev) {
            cur = cur->right;
        //没有 出栈
        } else {
            sta.pop();
            nodes.push_back(cur->val);
            prev = cur;
            cur = nullptr;
        }   
    }
}

(BFS)二叉树的层次遍历-剑指 Offer II 043 044 045 046

二叉树的层次遍历实现步骤：

1.定义队列queue存储树的节点
2.根节点入队列
3.当数组不为空时，遍历数组（提前确定队列queue的最大值）
4.获取队列头节点
5.将当前节点的子节点加入队列中

剑指 Offer II 043. 往完全二叉树添加节点

c++实现

class CBTInserter {
private:
    queue<TreeNode*> que;
    TreeNode* root;
public:
    //构建树
    CBTInserter(TreeNode* root) {
        this->root = root;
        //根节点进入队列
        que.push(root);
        while(que.front()->left != nullptr && que.front()->right != nullptr){
            que.push(que.front()->left);
            que.push(que.front()->right);
            que.pop();
        }
    }
    
    int insert(int v) {
        //定义要插入的节点
        TreeNode* node =new TreeNode(v);
        //标记指向头节点
        TreeNode* fa = que.front();
        if(fa->left == nullptr){
            fa->left = node;
        }
        else{
            fa->right = node;
            //当根节点为左右节点都有时，将左右节点入队列，根节点出队列
            que.push(fa->left);
            que.push(fa->right);
            que.pop();
        }
        return fa->val;
    }
    
    TreeNode* get_root() {
        return this->root;
    }
};

golang实现

type CBTInserter struct {
    root *TreeNode
    queue  []*TreeNode
}

func Constructor(root *TreeNode) CBTInserter {
    //判断根节点是否为空
    if root == nil {
		return CBTInserter{nil,[]*TreeNode{}}
	}
    //go没有类 所有需要声明数组变量
    var queue []*TreeNode 
    //将根节点加入队列
    queue = append(queue,root)
    for len(queue)>0 {
        node := queue[0]
        if node.Left != nil {
            queue = append(queue,node.Left)
        }else{
            break
        }
        if node.Right != nil {
            queue = append(queue,node.Right)
        }else{
            break
        }
        queue = queue[1:]
    }
    return CBTInserter{root,queue}
}

func (this *CBTInserter) Insert(v int) int {
    //标记头节点
    var parentVal int
    parentVal = this.queue[0].Val
    node := &TreeNode{Val:v}
    this.queue = append(this.queue,node)
    if this.queue[0].Left == nil {
        this.queue[0].Left = node
    }else{
        this.queue[0].Right = node
        this.queue=this.queue[1:]
    }
    return  parentVal//必须定义 不能直接返回this.queue[0].Val 因为上面已经this.queue=this.queue[1:]
}

func (this *CBTInserter) Get_root() *TreeNode {
    return this.root
}

剑指 Offer II 044. 二叉树每层的最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。


实现步骤：

1.空根节点的判断
2.定义向量容器存储最大值的集合
3.定义队列存储树的节点
4.根节点入队列
5.遍历数组
6.获取队列头节点
7.更新最大值
8.将当前节点的子节点加入队列中
9.将每层的最大值加入到向量容器中
10.返回最大数组

c++实现：

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        //空根节点的判断
        if (root == nullptr){
            return {};
        }
        vector<int> allmax;
        queue<TreeNode*> que;
        //根节点入队列
        que.push(root);
        while(!que.empty()){
            //size 必须在进入 for 循环前就确定，而不是使用 que.size()，因为队列大小实时在改变。
            int size = que.size();
            int curmax = INT_MIN;//int类型最小值
            for (int i = 0; i < size; i++){
                //获取队列头节点
                TreeNode* node = que.front();
                que.pop();
                //更新最大值
                curmax = max(curmax,node->val);
                //将当前节点的子节点加入队列中
                if(node->left != nullptr){
                    que.push(node->left);
                }
                if(node->right != nullptr){
                    que.push(node->right);
                }
            }
            //加入到最大向量组中
            allmax.push_back(curmax);
        }
        return allmax;
    }
};

golang实现

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func largestValues(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }
    var allmax []int
    var queue []*TreeNode
    queue = append(queue,root)
    for len(queue)>0 {
        size := len(queue)
        var curmax int = math.MinInt32//32位的整数范围的最小值
        for i:=0;i<size;i++ {
            node := queue[0];
            queue = queue[1:]
            curmax = max(curmax,node.Val)
            if node.Left != nil {
                queue = append(queue,node.Left)
            }
            if node.Right != nil {
                queue = append(queue,node.Right)
            }
        }
        allmax = append(allmax,curmax)
    }
    return allmax
}

func max(a,b int) int {
    if a>b {
        return a
    } 
    return b
}

剑指 Offer II 045. 二叉树最底层最左边的值

c++实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        que.push(root);
        int bottomleft;
        while(!que.empty()){
            int size = que.size();//que的大小要提前确定，que.size()是变化的，不是固定的。
            for(int i=0;i<size;i++){
                TreeNode* node = que.front();
                que.pop();
                //更新树的最左边的值  
                if(i==0){
                    bottomleft = node->val;
                }
                if(node->left != nullptr){
                    que.push(node->left);
                }
                if(node->right != nullptr){
                    que.push(node->right);
                }
            }
        }
        return bottomleft;
    }
};

golang实现

func findBottomLeftValue(root *TreeNode) int {
    var queue[]*TreeNode
    queue = append(queue,root)
    var bottomleft int
    for len(queue)>0 {
        size := len(queue)
        for i:=0;i<size;i++ {
            node := queue[0]
            queue = queue[1:]
            if i == 0 {
                bottomleft = node.Val
            }
            if node.Left != nil {
                queue=append(queue,node.Left)
            }
            if node.Right != nil {
                queue=append(queue,node.Right)
            }
        }
    }
    return bottomleft
}

剑指 Offer II 046. 二叉树的右侧视图

思路：

c++实现：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        if(root == nullptr){
            return {};
        }
        queue<TreeNode*> que;
        vector<int> rightSide;
        que.push(root);
        while(!que.empty())
        {
            int size = que.size();
            for(int i=0;i<size;i++)
            {
                TreeNode* node = que.front();
                que.pop();
                if(i == size-1)
                {
                    rightSide.push_back(node->val);
                }
                if(node->left != nullptr)
                {
                    que.push(node->left);
                }
                if(node->right != nullptr)
                {
                    que.push(node->right);
                }
            }
        }
        return rightSide;
    }
};

golang实现

func rightSideView(root *TreeNode) []int {
    if root==nil {
        return []int{}
    }
    var queue []*TreeNode
    var view []int
    queue = append(queue,root)
    for len(queue)>0 {
        size := len(queue)
        for i:=0;i<size;i++ {
            node := queue[0]
            queue = queue[1:]
            if i==(size-1) {
                view = append(view,node.Val)
            }
            if node.Left != nil {
                queue=append(queue,node.Left)
            }
            if node.Right != nil {
                queue=append(queue,node.Right)
            }
        }
    }
    return view
}