算法練習__二叉查找樹

代碼只是一時的思考，算法和架構是一直需要思考的。樹結構是遞歸的最好練習方式，文章找一些基本二叉查找樹的題目練習一下。主要涉及到查找最小元素、統計元素個數等問題

• 遍歷找最小距離
• 添加元素、查找最小元素
• 順序打印元素
• 求二叉樹深度，深度優先搜索
• 查找第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;
    }
}