二叉树的遍历与搜索

记得深度优先用的是栈,广度优先用的是队列

深度优先包括我们之前说的前序中序后续遍历方法

广度优先就是层次遍历

package toyprogram;

import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.ArrayBlockingQueue;

class TreeNode {
    Object val = null;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;
    }
    public TreeNode(TreeNode l,TreeNode r,Object o) {
        left=l;
        right=r;
        val=o;
    }

}

public class Solution {
    public static void main(String[] args) {
        TreeNode treeNode=getTree();
        depthFirstSearch(treeNode);
        System.out.println("*****");
        breadthFirstSearch(treeNode);
    }
    public static TreeNode getTree(){
        TreeNode G = new TreeNode(null, null, 'G');
        TreeNode H = new TreeNode(null, null, 'H');
        TreeNode F = new TreeNode(G, H, 'F');
        TreeNode D = new TreeNode(null, F, 'D');
        TreeNode E = new TreeNode(null, null, 'E');
        TreeNode B = new TreeNode(D, E, 'B');
        TreeNode C = new TreeNode(null, null, 'C');
        TreeNode A = new TreeNode(B, C, 'A');
        return A;
    }
    
    public static void breadthFirstSearch(TreeNode root){
        Queue<TreeNode> queue=new ArrayBlockingQueue<TreeNode>(10);
        
        if (root!=null) {
            queue.add(root);
        }else {
            return;
        }
        
        while (!queue.isEmpty()) {
            TreeNode t=queue.poll();
            System.out.print(t.val);
            if (t.left!=null) 
                queue.add(t.left);
            
            if(t.right!=null)
                queue.add(t.right);
            
        }
    }
    
    public static void depthFirstSearch(TreeNode root) {
        Stack<TreeNode> s=new Stack<>();
        if (root!=null) {
            s.push(root);
        }else {
            return;
        }
        
        while (!s.empty()) {
            TreeNode treeNode=s.pop();
            System.out.print(treeNode.val);
            if (treeNode.right!=null) 
                s.push(treeNode.right);
            
            if (treeNode.left!=null) 
                s.push(treeNode.left);
            
            
        }
    }
}

这两天面试,人家让写二叉树的查找,想了一下,代码如下:

/**
   * 递归解法
   * 
   * @param t
   * @param target
   * @return
   */
  public static TreeNode findTreeWithRecursion(TreeNode t, int target) {

    if (t != null) {
      if (t.val == target) {
        return t;
      }
      TreeNode t1, t2;
      t1 = findTreeWithRecursion(t.left, target);
      if (t1 != null)
        return t1;

      // 如果把下面的代码 上移3行 效率就会降低很多
      // 大家能理解么?
      t2 = findTreeWithRecursion(t.right, target);
      if (t2 != null)
        return t2;

      return null;

    } else {
      return null;
    }

  }

  /**
   * 非递归解法
   * 
   * @param t
   * @param target
   * @return
   */
  public static TreeNode findTreeWithoutRecursion(TreeNode t, int target) {

    Stack<TreeNode> s = new Stack<>();
    if (t != null) {
      s.push(t);
    } else {
      return null;
    }

    while (!s.empty()) {
      TreeNode treeNode = s.pop();
      if (t.val == target) {
        return t;
      }
      if (treeNode.right != null) {
        s.push(treeNode.right);
      }
      if (treeNode.left != null) {
        s.push(treeNode.left);
      }

    }

    return null;
  }