记得深度优先用的是栈,广度优先用的是队列
深度优先包括我们之前说的前序中序后续遍历方法
广度优先就是层次遍历
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;
}