java查缺补漏之第十七天（加油）

浅浅的花香味﹌ 2023-07-14 05:51 17阅读 0赞

**1.二叉树非递归实现前中后遍历。**

前序遍历

/**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     int val;
     *     TreeNode left;
     *     TreeNode right;
     *     TreeNode(int x) { val = x; }
     * }
     */
    class Solution {
        public List<Integer> preorderTraversal(TreeNode root) {
            TreeNode cur=root;
            Stack<TreeNode> stack=new Stack<>();
            List<Integer> result=new ArrayList<>();
            while(!stack.isEmpty()||cur!=null)
            {
                while(cur!=null)
                {
                    result.add(cur.val);
                    stack.push(cur);
                    cur=cur.left;
                }
                //取出一个进行回溯
                cur=stack.pop();
                cur=cur.right;
            }
            return result;
        }
    }

中序遍历：

/**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     int val;
     *     TreeNode left;
     *     TreeNode right;
     *     TreeNode(int x) { val = x; }
     * }
     */
    class Solution {
        public List<Integer> inorderTraversal(TreeNode root) {
            TreeNode cur=root;
            Stack<TreeNode> stack=new Stack<>();
            List<Integer> result=new ArrayList<>();
            while(!stack.isEmpty()||cur!=null)
            {
                while(cur!=null)
                {
                    stack.push(cur);
                    cur=cur.left;
                }
                cur=stack.pop();
                //从栈中取出一个对右进行回溯
                result.add(cur.val);
                cur=cur.right;
            }
            return result;
        }
    }

后序遍历：

/**
     * Definition for a binary tree node.
     * public class TreeNode {
     *     int val;
     *     TreeNode left;
     *     TreeNode right;
     *     TreeNode(int x) { val = x; }
     * }
     */
    class Solution {
        public List<Integer> postorderTraversal(TreeNode root) {
            TreeNode cur=root;
            TreeNode last=null;
            Stack<TreeNode> stack=new Stack<>();
            List<Integer> result=new ArrayList<>();
            while(!stack.isEmpty()||cur!=null)
            {
                while(cur!=null)
                {
                    stack.push(cur);
                    cur=cur.left;
                }
                TreeNode top=stack.peek();
                if(top.right==null||top.right==last)
                {
                    result.add(top.val);
                    stack.pop();
                    last=top;
                }else
                {
                    cur=top.right;
                }
            }
            return result;
        }
    }

**2.什么时候用字符流，什么时候用字节流。**

字节流和字符流的使用非常相似，两者除了操作代码上的不同之外，是否还有其他的不同呢？  
  
实际上字节流在操作时本身不会用到缓冲区（内存），是文件本身直接操作的，而字符流在操作时使用了缓冲区，通过缓冲区再操作文件，如图所示。  
![format_png][]

在关闭字符流时会强制性地将缓冲区中的内容进行输出，但是如果程序没有关闭，则缓冲区中的内容是无法输出的。

如果想在不关闭时也可以将字符流的内容全部输出，则可以使用Writer类中的flush()方法完成。

学习完字节流和字符流的基本操作后，已经大概地明白了操作流程的各个区别，那么在开发中是使用字节流好还是字符流好呢？  
  
回答：使用字节流更好。  
  
在回答之前，先为读者讲解这样的一个概念，所有的文件在硬盘或在传输时都是以字节的方式进行的，包括图片等都是按字节的方式存储的，而字符是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。

[format_png]: /images/20230529/4cf757616e864e05b2aaed9bb52697e5.png