1. 自定义树TreeNode
public class TreeNode {
private String value;
private TreeNode right;
private TreeNode left;
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public TreeNode getRight() {
return right;
}
public void setRight(TreeNode right) {
this.right = right;
}
public TreeNode getLeft() {
return left;
}
public void setLeft(TreeNode left) {
this.left = left;
}
@Override
public String toString() {
return value;
}
}
遍历前先介绍一下java中的栈和队列,在java中stack的实现我们可以用Deque接口(不直接使用Stack类),这个类是同时拥有栈和队列的特性,如下图,自己看一下源码就清楚了。Deque的实现类可以用ArrayDeque,也可以用LInkedList。
2. 在main函数中准备测试数据
TreeNode a = new TreeNode();
TreeNode b = new TreeNode();
TreeNode c = new TreeNode();
TreeNode d = new TreeNode();
TreeNode e = new TreeNode();
TreeNode f = new TreeNode();
TreeNode g = new TreeNode();
a.setValue("a");
b.setValue("b");
c.setValue("c");
d.setValue("d");
e.setValue("e");
f.setValue("f");
g.setValue("g");
b.setLeft(d);
b.setRight(e);
c.setLeft(f);
c.setRight(g);
a.setLeft(b);
a.setRight(c);
以上数据代表如下二叉树:
3. 深度优先的遍历方式(DFS)
DFS利用了Stack的先进后出特性
/**
* DFS广度优先,使用stack,先进后出
*
* @param root
* @return
*/
public static List<TreeNode> getNodesDFS(TreeNode root) {
List<TreeNode> ans = new ArrayList<>();
Deque<TreeNode> stack = new LinkedList<>();
stack.add(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
ans.add(node);
if (node.getRight() != null) {
stack.push(node.getRight());
}
if (node.getLeft() != null) {
stack.push(node.getLeft());
}
}
return ans;
}
4. 广度优先的遍历方式(BFS)
BFS利用的是队列的先进先出特性
/**
* BFS深度优先,利用队列的先进先出
* @param root
* @return
*/
public static List<TreeNode> getNodesBFS(TreeNode root) {
List<TreeNode> ans = new ArrayList<>();
Queue<TreeNode> queue = new ArrayDeque<>();
queue.add(root);
while (!queue.isEmpty()) {
TreeNode node = queue.remove();
ans.add(node);
if (node.getLeft() != null) {
queue.add(node.getLeft());
}
if (node.getRight() != null) {
queue.add(node.getRight());
}
}
return ans;
}
判断二叉搜索树(BST)
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 boolean isValidBST(TreeNode root) {
return isValidBST(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
}
public boolean isValidBST(TreeNode node, Integer lower, Integer upper) {
if (node == null) {
return true;
}
if (node.val >= Integer.MAX_VALUE || node.val <= Integer.MIN_VALUE) {
return false;
}
return isValidBST(node.left, lower, node.val) && isValidBST(node.right, node.val, upper);
}
public static void main(String[] args) {
TreeNode n5 = new TreeNode(5);
TreeNode n1 = new TreeNode(1);
TreeNode n3 = new TreeNode(3);
TreeNode n4 = new TreeNode(4);
TreeNode n6 = new TreeNode(6);
n4.left = n3;
n4.right = n6;
n5.left = n1;
n5.right = n4;
System.out.println(new Solution().isValidBST(n5));
;
}
}