算法训练营(第一期)

算法训练营(第一期)第十二天(java)

学习感悟:

---

---

题目

---

一、递归遍历二叉树(leetcode144,145,94)

题目

只写一个中序遍历其余两个改变一下中间步骤的顺序即可

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ls=new LinkedList();
        find(ls,root);
        return ls;
    }
    //写递归要注意的一些东西,传入参数,返回值,中间步骤,停止条件
    public void find(List ls,TreeNode root){
        if(root==null) return;
        find(ls,root.left);
        ls.add(root.val);
        find(ls,root.right);
    }


}

二、迭代遍历二叉树(leetcode144,145,94)

题目

前序遍历:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        //非递归方法来写二叉树遍历,要使用栈这一种数据结构来模拟递归的过程
        Stack<TreeNode> st=new Stack();
        //利用list来保存递归的结果
        List<Integer> list=new LinkedList();
        st.push(root);
        while(!st.isEmpty()){
            //当st不为空的时候呢,就处理st
            //如果传入的节点为空就跳出该次循环
            TreeNode tn=st.pop();
            if(tn==null) continue;
            //否则就接着处理这个节点.
            list.add(tn.val);
            //先传入右边再传入左边因为栈是先入后出的数据结构
            st.push(tn.right);
            st.push(tn.left);
            
        }
        return list;

    }
}

后序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
           //非递归方法来写二叉树遍历,要使用栈这一种数据结构来模拟递归的过程
        Stack<TreeNode> st=new Stack();
        //利用list来保存递归的结果
        List<Integer> list=new LinkedList();
        st.push(root);
        while(!st.isEmpty()){
            //当st不为空的时候呢,就处理st
            //如果传入的节点为空就跳出该次循环
            TreeNode tn=st.pop();
            if(tn==null) continue;
            //否则就接着处理这个节点.
            list.add(tn.val);
            //先传入右边再传入左边因为栈是先入后出的数据结构
             st.push(tn.left);
            st.push(tn.right);
           
            
        }
        Collections.reverse(list);
        return list;

    }
}

中序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        //中序遍历与前序和后序是不太一样的因为正在遍历的元素和要处理的元素不太一样,当我们要进行二叉树的遍历的时候要谨记遍历与处理这两个步骤.
        //保存当前遍历到的元素
            TreeNode cur=root;
            //表示节点遍历的过程
            Stack<TreeNode> st=new Stack();
            //用以保存结果
            List<Integer> list=new LinkedList();
           
            while(!st.isEmpty()||cur!=null){
               
                if(cur!=null){
                   
                     st.push(cur);
                      cur=cur.left;
                }else{
                  cur= st.pop();
                  list.add(cur.val);
                  cur=cur.right;
                }
            }
return list;

    }
}