上好的刷题Day12

【递归法前序遍历】

上好的刷题Day12_第1张图片

 上好的刷题Day12_第2张图片

        Stack stack = new Stack<>();
        List list = new ArrayList<>();
        TreeNode p = root;
        if(p==null)
            return list;
        stack.push(p);
        while(stack.size()>0){
            p = stack.pop();
            list.add(p.val);
            if(p.right != null)
                stack.push(p.right);
            if(p.left != null)
                stack.push(p.left);           
        }
        return list;

【中序遍历遍历】

上好的刷题Day12_第3张图片

上好的刷题Day12_第4张图片

public List inorderTraversal(TreeNode root) {
        List list = new ArrayList<>();
        Stack stack = new Stack<>();

        TreeNode  p = root;
        while(p != null ||stack.size()>0){
            if( p != null){
                stack.push(p);
                p = p.left;
            }else{
                p = stack.peek();
                stack.pop();
                list.add(p.val);
                p = p.right;           
            }
        }
        return list;
    }

【后序遍历】

前序 - > [ 中,左,右]      后序 ->  [左,右, 中]

class Solution {
public:
    vector postorderTraversal(TreeNode* root) {
        stack st;
        vector result;
        if (root == NULL) return result;
        st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            result.push_back(node->val);
            if (node->left) st.push(node->left); // 相对于前序遍历,这更改一下入栈顺序 (空节点不入栈)
            if (node->right) st.push(node->right); // 空节点不入栈
        }
        reverse(result.begin(), result.end()); // 将结果反转之后就是左右中的顺序了
        return result;
    }
};
# 用栈实现
class Solution {
    public List postorderTraversal(TreeNode root) {
        List res = new ArrayList();
        if (root == null) {
            return res;
        }

        Deque stack = new LinkedList();
        TreeNode prev = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if (root.right == null || root.right == prev) {
                res.add(root.val);
                prev = root;
                root = null;
            } else {
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }
}

上好的刷题Day12_第5张图片

 prev标记是否是从右子树访问完成后,再进入根节点,因为

  1. 左子树访问完成,回到根节点,再访问右子树,此时不打印根节点
  2. 右子树访问完成,回到根节点,打印根节点,prev就是判断是都相等

【统一风格前中后】

//========================前序=============
class Solution {
    public List preorderTraversal(TreeNode root) {
        List result = new LinkedList<>();
        Stack st = new Stack<>();
        if (root != null) st.push(root);
        while (!st.empty()) {
            TreeNode node = st.peek();
            if (node != null) {
                st.pop(); // 将该节点弹出,避免重复操作,下面再将右中左节点添加到栈中
                if (node.right!=null) st.push(node.right);  // 添加右节点(空节点不入栈)
                if (node.left!=null) st.push(node.left);    // 添加左节点(空节点不入栈)
                st.push(node);                          // 添加中节点
                st.push(null); // 中节点访问过,但是还没有处理,加入空节点做为标记。
                
            } else { // 只有遇到空节点的时候,才将下一个节点放进结果集
                st.pop();           // 将空节点弹出
                node = st.peek();    // 重新取出栈中元素
                st.pop();
                result.add(node.val); // 加入到结果集
            }
        }
        return result;
    }
}
// =======================中序=================
            st.pop(); // 将该节点弹出,避免重复操作,下面再将右中左节点添加到栈中
            if (node.right!=null) st.push(node.right);  // 添加右节点(空节点不入栈)
            st.push(node);                          // 添加中节点
            st.push(null); // 中节点访问过,但是还没有处理,加入空节点做为标记。
            if (node.left!=null) st.push(node.left);    // 添加左节点(空节点不入栈)
// =======================后序=================
                st.pop(); // 将该节点弹出,避免重复操作,下面再将右中左节点添加到栈中
                st.push(node);                          // 添加中节点
                st.push(null); // 中节点访问过,但是还没有处理,加入空节点做为标记。
                if (node.right!=null) st.push(node.right);  // 添加右节点(空节点不入栈)
                if (node.left!=null) st.push(node.left);    // 添加左节点(空节点不入栈)

【思路】栈里面红色节点,表示的就是,当前前一个节点还没有访问,两个一起出栈,访问前一个节点,只有红色出栈了,再往里面加,所以根据前中后顺序可以统一遍历

上好的刷题Day12_第6张图片

 

 

你可能感兴趣的:(java)