二叉树两种遍历方式

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));
        ;
    }
}

参考文章

好文推荐
红黑树动态演示