二叉树的学习

第一：二叉树的统一秩代遍历

深度优先遍历：注意写秩代的代码时，在中之后添加null，出栈和添加结果集的方式是一样的。

例如前序遍历：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
        Stack<TreeNode> 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;
    }
}

后序遍历：

class s1{
    public List<Integer> inorderTraversal(TreeNode root) {
        //后序列遍历
      Stack<TreeNode> tr=new Stack<>();
      List<Integer> lis=new ArrayList<>();
      TreeNode node;
      if(root==null) return lis;
      tr.push(root);
      while(!tr.empty()){
          node=tr.peek();
          if(node!=null){
              tr.push(null);
              if(node.right!=null) tr.push(node.right);
              if(node.left!=null) tr.push(node.left);
          }else {
              tr.pop();
              lis.add(tr.pop().val);
          }
      }
      return lis;

    }
}

中序遍历：

class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new LinkedList<>();
    Stack<TreeNode> 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);  // 添加右节点（空节点不入栈）
            st.push(node);                          // 添加中节点
            st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。

            if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）
        } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
            st.pop();           // 将空节点弹出
            node = st.peek();    // 重新取出栈中元素
            st.pop();
            result.add(node.val); // 加入到结果集
        }
    }
    return result;
}
}

步骤：

先写出遍历时的顺序：例如左中右

当栈的第一个节点不是null时，按照上述顺序相反的入栈，并在中入栈后加入一个null入栈作为标记。

当栈的第一个节点是null时，将null弹出后，将下一个节点弹出并加入结果集

二叉树的层序遍历

BFS(广度优先遍历)，其利用一个队列来遍历，其将每层的长度计算出来，以之来设置循环

// 102.二叉树的层序遍历
class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        //checkFun01(root,0);
        checkFun02(root);

        return resList;
    }

    //DFS--递归方式
    public void checkFun01(TreeNode node, Integer deep) {
        if (node == null) return;
        deep++;

        if (resList.size() < deep) {
            //当层级增加时，list的Item也增加，利用list的索引值进行层级界定
            List<Integer> item = new ArrayList<Integer>();
            resList.add(item);
        }
        resList.get(deep - 1).add(node.val);

        checkFun01(node.left, deep);
        checkFun01(node.right, deep);
    }

    //BFS--迭代方式--借助队列
    public void checkFun02(TreeNode node) {
        if (node == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(node);

        while (!que.isEmpty()) {
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();

            while (len > 0) {
                TreeNode tmpNode = que.poll();
                itemList.add(tmpNode.val);

                if (tmpNode.left != null) que.offer(tmpNode.left);
                if (tmpNode.right != null) que.offer(tmpNode.right);
                len--;
            }

            resList.add(itemList);
        }

    }
}

秩代的方式较为简单

递归层序遍历二叉树，程序运行也不是一层层运行的，但数据是一层层的存储的，这点需要理解

秩代深度优先遍历：用栈

秩代层优先遍历：用队列