算法练习__二叉查找树

代码只是一时的思考，算法和架构是一直需要思考的。树结构是递归的最好练习方式，文章找一些基本二叉查找树的题目练习一下。主要涉及到查找最小元素、统计元素个数等问题

• 遍历找最小距离
• 添加元素、查找最小元素
• 顺序打印元素
• 求二叉树深度，深度优先搜索
• 查找第k个最小元素
• 求二叉树的节点数

/**
 * 二叉查找树基本结构
 * @author 
 *
 */
public class BinaryTree {
    int initDis = Integer.MAX_VALUE;
    BinaryTreeNode prev;  //保存遍历到的上一个节点
    public BinaryTreeNode root;

    int kthFind;  //找第kthFind元素

    public int getMininumDis(BinaryTreeNode root) {
        inOrder(root);
        return 0;
    }
    /**
     * 遍历找最小距离，这个遍历的顺序与下面的printBinaryTreeNode排序打印方法比较像
     * @param root
     */
    public void inOrder(BinaryTreeNode root) {
        if (null == root) {
            return;
        }
        inOrder(root.left);
        if (null != prev) {
            initDis = Math.min(initDis, Math.abs(root.val - prev.val));
        }
        prev = root;
        inOrder(root.right);
    }

    /**
     * 插入元素
     * @param root
     * @return
     */
    public BinaryTree insert(int i) {
        this.root = insertNode(i, this.root);
        return this;
    }

    public BinaryTreeNode insertNode(int i, BinaryTreeNode root) {
        if (null == root) {
            return new BinaryTreeNode(i);
        }

        if (i <= root.val) {
            root.left = insertNode(i, root.left);
        }
        if (i > root.val) {
            root.right = insertNode(i, root.right);
        }
        return root;
    }

    public BinaryTreeNode findMin(BinaryTreeNode root) {
        if (null == root.left) {
            return root;
        }
        return findMin(root.left);
    }

    //排序打印，中序遍历
    public void printBinaryTreeNode(BinaryTreeNode root) {
        if(null == root) {
            return;
        }
        printBinaryTreeNode(root.left);  //先打印左边小的
        System.err.println(root.val);  //再打印自己, 也是遍历的前一个
        printBinaryTreeNode(root.right);  //再打印右边大的
        /**
         * 以上先前序后后序遍历与sort方法有点像，都是将处理过程放在中间处理
         */
    }

    /**
     * 深度优先遍历
     * @param root
     * @return
     */
    public List<String> binaryTreePaths(BinaryTreeNode root) {
        List<String> paths = new ArrayList<>();
        if (null == root) {
            return paths;
        }
        dfs(root, paths, root.val + "");
        return paths;
    }

    private void dfs(BinaryTreeNode node, List<String> paths, String a) {
        if (node.left == null && node.right == null) {
            paths.add(a);
            return;
        }
        if (node.left != null) {
            dfs(node.left, paths, a + "->" + node.left.val);
        }
        if (node.right != null) {
            dfs(node.right, paths, a + "->" + node.right.val);
        }
    }

    /**
     * BST找第k个最小元素
     * @param root
     * @param k
     * @return
     */
    public BinaryTreeNode findKthSmallestElem(BinaryTreeNode root, int k) {
        BinaryTreeNode kthNode = new BinaryTreeNode(0);
        findKthSmallestNode(root, kthNode, k);
        this.kthFind = 0;
        return kthNode;
    }

    private void findKthSmallestNode(BinaryTreeNode root, BinaryTreeNode kth, int k) {
        if (this.kthFind > k) {
            return;
        }
        if (null != root.left) {
            findKthSmallestNode(root.left, kth, k);
        }
        this.kthFind++;
        if (this.kthFind == k) {
            kth = root;
            return;
        }
        if (null != root.right) {
            findKthSmallestNode(root.right, kth, k);
        }

    }

    /**
     * 计算树所有的节点数量
     * @param root
     * @return
     */
    public int sizeOfBinaryTree(BinaryTreeNode root) {
        if (null == root) {
            return 0;
        }

        int leftNum = sizeOfBinaryTree(root.left);
        int rightNum = sizeOfBinaryTree(root.right);
        return 1 + leftNum + rightNum;
    }

    /**
     * 求出二叉树的深度
     * @param root
     * @return
     */
    public int deptOfBinaryTree(BinaryTreeNode root) {
        if (null == root) {
            return 0;
        }

        int leftDept = 1;
        int rightDept = 1;
        leftDept += deptOfBinaryTree(root.left);
        rightDept += deptOfBinaryTree(root.right);
        return leftDept > rightDept ? leftDept : rightDept;
    }
}