LeetCode训练营之二叉树

一、binary-tree-preorder-traversal

Given a binary tree, return the preorder traversal of its nodes’ values.

方法一：递归实现前序遍历

	public ArrayList<Integer> preorderTraversal(TreeNode root) {
        //返回前序遍历结果
        ArrayList<Integer> result = new ArrayList<>();
        //边界值检测
        if(root == null)
            return result;
        //调用递归处理逻辑前序遍历二叉树
        preorderTraversalCore(root,result);
        return result;
    }
    private void preorderTraversalCore(TreeNode root,ArrayList<Integer> result){
        if(root == null)
            return;
        result.add(root.val);
        preorderTraversalCore(root.left,result);
        preorderTraversalCore(root.right,result);
    }

方法二：迭代实现前序遍历（栈）

 	public ArrayList<Integer> preorderTraversal(TreeNode root) {
        //返回的遍历结果
        ArrayList<Integer> result = new ArrayList<>();
        //边界值检验
        if(root == null)
            return result;
        //辅助数据结构——栈，实现递归遍历的操作
        Stack<TreeNode> stack = new Stack<>();
        //首先添加根节点
        stack.push(root);
        //循环进行节点的入栈和出栈，出一进二，进栈顺序右节点先进，左节点后进
        while(stack.size() != 0){ 
            TreeNode cur = stack.pop();
            if(cur.right != null)
                stack.push(cur.right);
            if(cur.left != null)
                stack.push(cur.left);
            result.add(cur.val);
        }
        return result;
    }

---

二、binary-tree-postorder-traversal

Given a binary tree, return the postorder traversal of its nodes’ values.

方法一：递归实现后序遍历

	public ArrayList<Integer> postorderTraversal(TreeNode root) {
	        //返回结果
	        ArrayList<Integer> result = new ArrayList<>();
	        //边界值校测
	        if(root == null)
	            return result;
	        //调用递归函数后序遍历二叉树
	        postorderTraversalCore(root,result);
	        return result;
	   }
	  //递归逻辑实现二叉树后序遍历
	  private void postorderTraversalCore(TreeNode root,ArrayList<Integer> result){
	        if(root == null)
	            return;
	        postorderTraversalCore(root.left,result);
	        postorderTraversalCore(root.right,result);
	        result.add(root.val);
	  }

方法二：迭代实现后序遍历（两栈）

   public ArrayList<Integer> postorderTraversal(TreeNode root) {
       //返回遍历结果
       ArrayList<Integer> result = new ArrayList<>();
       //边界值检测
       if(root == null)
           return result;
       //辅助栈一：用于保存中间节点
       Stack<TreeNode> stack1 = new Stack<>();
       //辅助栈二：用于保存反序的遍历结果
       Stack<Integer> stack2 = new Stack<>();
       stack1.push(root);
       //第一次遍历二叉树，将树节点按照后序遍历的顺序压入栈2
       while(!stack1.isEmpty()){
           TreeNode cur = stack1.pop();
           if(cur.left != null)
               stack1.push(cur.left);
           if(cur.right != null)
               stack1.push(cur.right);
           stack2.push(cur.val);
       }
       //弹出栈2的节点值到遍历结果线性表中
       while(stack2.size() != 0){
           result.add(stack2.pop());
       }
       return result;
   }

---

三、binary-tree-inorder-traversal

Given a binary tree, return the inorder traversal of its nodes’ values.

方法一：递归中序遍历二叉树

    public ArrayList<Integer> inorderTraversal(TreeNode root) {
     //返回结果
      ArrayList<Integer> result = new ArrayList<>();
      //边界值校测
      if(root == null)
          return result;
      //调用递归函数中序遍历二叉树
      inorderTraversalCore(root,result);
      return result;
  	}
  	 private void inorderTraversalCore(TreeNode root,ArrayList<Integer> result){
       if(root == null)
           return;
       inorderTraversalCore(root.left,result);
       result.add(root.val);
       inorderTraversalCore(root.right,result);
   }

方法二：迭代中序遍历二叉树（栈）

    public ArrayList<Integer> inorderTraversal(TreeNode root) {
       //返回中序遍历结果
       ArrayList<Integer> result = new ArrayList<>();
       //边界值检测
       if(root == null)
           return result;
       //辅助数据结构，用于模拟中序遍历过程
       Stack<TreeNode> stack = new Stack<>();
       while(!stack.isEmpty() || root != null){
           //走左子树方向深入
           if(root != null){
               stack.push(root);
               root = root.left;
           }else{
               //左子树方向走到底，弹出栈顶元素，并从右子节点向左开始深入
               TreeNode cur = stack.pop();
               result.add(cur.val);
               root = cur.right;
           }
       }
       return result;
   }

---

四、binary-tree-level-order-traversal

Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

   public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
       //返回的层序遍历结果
       ArrayList<ArrayList<Integer>> result = new ArrayList<>();
       //边界值检测
       if(root == null)
           return result;
       //当前层使用的队列
       Queue<TreeNode> queue1 = new LinkedList<>();
       //当前层的层序遍历结果
       queue1.offer(root);
       //保存当前层的遍历结果，并保存下一层的节点队列，依次循环
       while(queue1.size() != 0){
           //存放当前层的层序遍历结果
           ArrayList<Integer> temp = new ArrayList<>();
           //一定要保存当前层的节点数，用于后续的节点出队，和下一层的节点入队
           int len = queue1.size();
           //记录下一层的节点队列
           Queue<TreeNode> queue2 = new LinkedList<>();
           for(int i = 0 ; i < len ; i++){
               TreeNode cur = queue1.poll();
               if(cur.left != null)
                   queue2.offer(cur.left);
               if(cur.right != null)
                   queue2.offer(cur.right);
               temp.add(cur.val);
           }
           result.add(temp);
           queue1 = queue2;
       }
       return result;
   }

---

五、binary-tree-level-order-traversal

Given a binary tree, return the bottom-up level order traversal of its nodes’ values. (ie, from left to right, level by level from leaf to root).

   public ArrayList<ArrayList<Integer>> levelOrderBottom(TreeNode root) {
       //返回的层序遍历结果
      ArrayList<ArrayList<Integer>> result = new ArrayList<>();
      //边界值检测
      if(root == null)
          return result;
      //当前层使用的队列
      Queue<TreeNode> queue1 = new LinkedList<>();
      //当前层的层序遍历结果
      queue1.offer(root);
      //保存当前层的遍历结果，并保存下一层的节点队列，依次循环
      while(queue1.size() != 0){
          //存放当前层的层序遍历结果
          ArrayList<Integer> temp = new ArrayList<>();
          //一定要保存当前层的节点数，用于后续的节点出队，和下一层的节点入队
          int len = queue1.size();
          //记录下一层的节点队列
          Queue<TreeNode> queue2 = new LinkedList<>();
          for(int i = 0 ; i < len ; i++){
              TreeNode cur = queue1.poll();
              if(cur.left != null)
                  queue2.offer(cur.left);
              if(cur.right != null)
                  queue2.offer(cur.right);
              temp.add(cur.val);
          }
          result.add(temp);
          queue1 = queue2;
      }
       //相比上一题，只多了下面这段代码
      int begin = 0;
      int end = result.size() - 1;
      while(begin < end){
          ArrayList<Integer> temp = result.get(begin);
          result.set(begin,result.get(end));
          result.set(end,temp);
          begin++;
          end--;
      }
      return result;
   }

---

五、binary-tree-zigzag-level-order-traversal

Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).

	  public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
	      //返回的层序遍历结果
	      ArrayList<ArrayList<Integer>> result = new ArrayList<>();
	      //边界值检测
	      if(root == null)
	        return result;
	      //当前层
	      Stack<TreeNode> stack1 = new Stack<>();
	      //下一层
	      Stack<TreeNode> stack2;
	      //当前层的遍历结果
	      ArrayList<Integer> temp;
	      //第一层
	      stack1.push(root);
	      boolean ltr = true;
	      //循环处理每一层
	      while(stack1.size() != 0){
	          temp = new ArrayList<Integer>();
	          stack2 = new Stack<>();
	          //先添加左子节点，再添加右子节点
	           if(ltr){
	               while(stack1.size() != 0){
	                   TreeNode cur = stack1.pop();
	                   if(cur.left != null)
	                       stack2.push(cur.left);
	                   if(cur.right != null)
	                       stack2.push(cur.right);
	                   temp.add(cur.val);
	               }
	           }else{
	               //先添加右子节点，再添加左子节点
	               while(stack1.size() != 0){
	                   TreeNode cur = stack1.pop();
	                   if(cur.right != null)
	                       stack2.push(cur.right);
	                   if(cur.left != null)
	                       stack2.push(cur.left);
	                   temp.add(cur.val);
	               }
	           }
	          //更新当前层的栈
	          stack1 = stack2;
	          //添加当前层的遍历结果到返回结果中
	          result.add(temp);
	          //更新添加子节点方向
	          ltr = !ltr;
	      }
	      return result;
	  }

---

六、 construct-binary-tree-from-preorder-and-inorder-traversal

Given preorder and inorder traversal of a tree, construct the binary tree.

	  public TreeNode buildTree(int[] preorder, int[] inorder) {
	      //参数合法性校验
	      if(preorder == null || inorder == null || preorder.length != inorder.length)
	          return null;
	      //数组长度，即节点个数
	      int len = preorder.length;
	      //调用递归逻辑实现二叉树重建
	      return buildTreeCore(preorder,0,len-1,inorder,0,len-1);
	  }
	  private TreeNode buildTreeCore(int[] pre,int beginPre,int endPre,int[] in,int beginIn,int endIn){
	      //数组中无元素，已到达叶子结点的叶子结点处
	      if(beginPre > endPre)
	          return null;
	      //在中序数组中找出与当前前序数组的第一个元素，并以此元素的下标进行划分，进一步递归处理左右子树
	      for(int i = beginIn ; i <= endIn ; i++){
	          if(in[i] != pre[beginPre])
	              continue;
	          //当前节点
	          TreeNode node = new TreeNode(pre[beginPre]);
	          //当前节点的左子树
	          node.left = buildTreeCore(pre,beginPre+1,beginPre+i-beginIn,in,beginIn,i-1);
	          //当前节点的右子树
	          node.right = buildTreeCore(pre,beginPre+i-beginIn+1,endPre,in,i+1,endIn);
	          return node;
	      }
	      return null;
	  }

---

七、construct-binary-tree-from-inorder-and-postorder-traversal

Given inorder and postorder traversal of a tree, construct the binary tree.

   public TreeNode buildTree(int[] inorder, int[] postorder) {
       //参数合法性校验
         if(postorder == null || inorder == null || postorder.length != inorder.length)
             return null;
         //数组长度，即节点个数
         int len = postorder.length;
         //调用递归逻辑实现二叉树重建
         return buildTreeCore(postorder,0,len-1,inorder,0,len-1);
   }
    private TreeNode buildTreeCore(int[] post,int beginPost,int endPost,int[] in,int beginIn,int endIn){
         //数组中无元素，已到达叶子结点的叶子结点处
         if(beginPost > endPost)
             return null;
         //在中序数组中找出与当前后续数组的倒数第一个元素，并以此元素的下标进行划分，进一步递归处理左右子树
         for(int i = beginIn ; i <= endIn ; i++){
             if(in[i] != post[endPost])
                 continue;
             //当前节点
             TreeNode node = new TreeNode(post[endPost]);
             //当前节点的左子树
             node.left = buildTreeCore(post,beginPost,beginPost+i-beginIn-1,in,beginIn,i-1);
             //当前节点的右子树
             node.right = buildTreeCore(post,beginPost+i-beginIn,endPost-1,in,i+1,endIn);
             return node;
         }
         return null;
     }