二叉树的各种概念以及代码操作

二叉树的各种概念以及代码操作

一、基本概念
* 每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒。
性质：
1. 非空二叉树的第n层上至多有2^(n-1)个元素。
2. 深度为h的二叉树至多有2^h-1个结点。
* 满二叉树：所有终端都在同一层次，且非终端结点的度数为2。
在满二叉树中若其深度为h，则其所包含的结点数必为2^h-1。
* 完全二叉树：只有最下面的两层结点度能够小于2，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树。
* 图样

树的三种遍历方式

前序遍历：根节点->左子树->右子树
中序遍历：左子树->根节点->右子树
后序遍历：左子树->右子树->根节点

例如：求下面树的三种遍历

前序遍历：abdefgc
中序遍历：debgfac
后序遍历：edgfbca

最优二叉树

• 又名哈夫曼树，定义：给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree)。哈夫曼树是带权路径长度最短的树，权值较大的结点离根较近。

二叉查找树（Binary Search Tree）

• 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。
• 二叉查找树的插入：从根节点进行对比，小于根节点，在根节点左子树进行对比；大于根节点，在根节点右子树进行对比。一直重复上述过程，当找到节点为空的地方插入。

• 二叉树的删除

  1. 被删除节点没有子树的情况，直接删除，并修改对应父节点的指针为空。
  2. 对于只有一个子树的情况，考虑将其子树作为其父节点的子树，关于是左还是右，根据被删除的节点确定。
  3. 最复杂的是有两个子数的情况，可以考虑两种方法，都是同样的思想：用被删除节点A的左子树的最右节点或者A的右子树的最左节点作为替代A的节点，并修改相应的最左或最右节点的父节点的指针，修改方法类似2 。

• 图样
  

各种二叉树操作代码算法

    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;

    /**
     * @author 高远</n>
     * 邮箱  wgyscsf@163.com</n>
     * 编写日期   2017-3-17下午2:31:24</n>
     * </n>
     */
    public class MyBinaryTreeList {
        BinaryTree root;

        // 定义二叉树
        class BinaryTree {
            BinaryTree left;
            BinaryTree right;
            int value;

            public BinaryTree(int value) {
                this.value = value;
            }

            public BinaryTree() {
                root = null;
            }
        }

        // 向二叉查找树插入数据
        boolean add(BinaryTree binaryTree,int value) {
            if (root == null) {
                root = new BinaryTree(value);
            } else {
                if (value < binaryTree.value) {
                    if (binaryTree.left == null) {
                        binaryTree.left = new BinaryTree(value);
                    } else {
                        add(binaryTree.left, value);
                    }
                } else {
                    if (binaryTree.right == null) {
                        binaryTree.right = new BinaryTree(value);
                    } else {
                        add(binaryTree.right, value);
                    }
                }
            }
            return true;
        }

        // 前序遍历
        void preScanner(BinaryTree binaryTree) {
            if (binaryTree == null)
                return;
            System.out.print(binaryTree.value + ",");
            preScanner(binaryTree.left);
            preScanner(binaryTree.right);
        }

        // 中序遍历
        void midScanner(BinaryTree binaryTree) {
            if (binaryTree == null)
                return;
            midScanner(binaryTree.left);
            System.out.print(binaryTree.value + ",");
            midScanner(binaryTree.right);
        }

        // 后序遍历
        void finScanner(BinaryTree binaryTree) {
            if (binaryTree == null)
                return;
            finScanner(binaryTree.left);
            finScanner(binaryTree.right);
            System.out.print(binaryTree.value + ",");
        }

        // 递归求树的深度
        int treeDeepByRecursion(BinaryTree binaryTree) {
            if (binaryTree == null)
                return 0;
            int leftDeep = treeDeepByRecursion(binaryTree.left);
            int rightDeep = treeDeepByRecursion(binaryTree.right);
            return leftDeep > rightDeep ? leftDeep + 1 : rightDeep + 1;
        }

        /*
         * 非递归求树的深度，思路：
         * 1.维护一个当前队列节点的长度a，在初始化一个长度为零的变量b。变量每次加一，取出一个数据，同时加入该节点的左右孩纸。当a=b,结束当前循环。
         * 2. 结束循环前维护一个深度l，深度l++。 3. 重复1,2。当队列时结束。
         */
        int treeDeepByNoRecursion(BinaryTree binaryTree) {
            if (binaryTree == null)
                return 0;
            // 维护一个队列，
            LinkedList<BinaryTree> binaryTreeList = new LinkedList<>();
            binaryTreeList.offer(binaryTree);
            int currentIndex;
            int lastIndex;
            BinaryTree currentBinaryTree;
            //深度
            int leval=0;
            //结束条件
            while(!binaryTreeList.isEmpty()){
                currentIndex=0;
                lastIndex=binaryTreeList.size();
                while (currentIndex < lastIndex) {
                    // poll取出一个元素，并从原来队列删除；peek查询第一个数据。
                    currentBinaryTree = binaryTreeList.poll();
                    currentIndex++;
                    // 以下是将下一层加入队列，在下次循环中进行计算
                    if (currentBinaryTree.left != null) {
                        binaryTreeList.offer(currentBinaryTree.left);
                    }
                    if (currentBinaryTree.right != null) {
                        binaryTreeList.offer(currentBinaryTree.right);
                    }
                }
                leval++;

            }
            return leval;

        }

        // 求树的宽度。思路和非递归求树的深度相对应。
        int treeWidth(BinaryTree binaryTree) {
            LinkedList<BinaryTree> linkedList = new LinkedList<>();
            linkedList.offer(binaryTree);
            int currentIndex;// 当前位置节点。
            int lastIndex;// 当前层最大节点的数量，即当前层树的宽度。
            BinaryTree currentBinaryTree;// 当前取出的节点。
            int maxLen = 0;// 最大层的值。
            while (!linkedList.isEmpty()) {
                currentIndex = 0;
                lastIndex = linkedList.size();
                while (currentIndex < lastIndex) {
                    currentBinaryTree = linkedList.poll();
                    currentIndex++;
                    // 以下是将下一层加入队列，在下次循环中进行计算
                    if (currentBinaryTree.left != null) {
                        linkedList.offer(currentBinaryTree.left);
                    }
                    if (currentBinaryTree.right != null) {
                        linkedList.offer(currentBinaryTree.right);
                    }
                }
                // 处理最大层的数量
                if (lastIndex > maxLen) {
                    maxLen = lastIndex;
                }
            }

            return maxLen;

        }

        // 找出二叉树的所有深度遍历路径
        ArrayList<Integer> list3 = new ArrayList<>();
        ArrayList<ArrayList<Integer>> listList3 = new ArrayList<>();

        private ArrayList<ArrayList<Integer>> getAllDeepPath(BinaryTree binaryTree) {
            if (binaryTree == null)
                return listList3;
            list3.add(binaryTree.value);
            if (binaryTree.left == null && binaryTree.right == null) {
                // 这种写法不行，原因：@param c the collection whose elements are to be placed
                // into this list
                // listList3.add(list3);
                listList3.add(new ArrayList<Integer>(list3));//
            }
            if (binaryTree.left != null)
                getAllDeepPath(binaryTree.left);
            if (binaryTree.right != null)
                getAllDeepPath(binaryTree.right);
            list3.remove(list3.size() - 1);
            return listList3;
        }

        // 在二叉树中找出和为某一值的所有路径
        List<Integer> list4 = new ArrayList<>();
        List<List<Integer>> allList4 = new ArrayList<>();
        private List<List<Integer>> getSpDeepTree(BinaryTree binaryTree, int target) {
            if (binaryTree == null)
                return allList4;
            list4.add(binaryTree.value);
            target -= binaryTree.value;
            if (target == 0 && binaryTree.left == null && binaryTree.right == null)
                allList4.add(new ArrayList<>(list4));
            if (binaryTree.left != null)
                getSpDeepTree(binaryTree.left, target);
            if (binaryTree.right != null)
                getSpDeepTree(binaryTree.right, target);

            list4.remove(list4.size() - 1);
            return allList4;
        }

        // test
        public static void main(String[] args) {
            int[] arr = new int[] { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
            MyBinaryTreeList binaryTreeList = new MyBinaryTreeList();
            for (int i = 0; i < arr.length; i++) {
                binaryTreeList.add(binaryTreeList.root, arr[i]);
            }
            System.out.println("前序遍历");
            binaryTreeList.preScanner(binaryTreeList.root);
            System.out.println("中序遍历");
            binaryTreeList.midScanner(binaryTreeList.root);
            System.out.println("后序遍历");
            binaryTreeList.finScanner(binaryTreeList.root);
            System.out.println();
            System.out.println("递归树的深度："
                    + binaryTreeList.treeDeepByRecursion(binaryTreeList.root));
            System.out.println("非递归树的深度："
                    + binaryTreeList.treeDeepByNoRecursion(binaryTreeList.root));
            System.out.println("递归树的宽度："
                    + binaryTreeList.treeWidth(binaryTreeList.root));

            System.out.println("在二叉树中找所有路径2:");
            ArrayList<ArrayList<Integer>> findPath3 = binaryTreeList
                    .getAllDeepPath(binaryTreeList.root);
            for (List<Integer> arrayList : findPath3) {
                for (Integer integer : arrayList) {
                    System.out.print(integer + ",");
                }
                System.out.println();
            }

            System.out.println("在二叉树中找出和为某一值的所有路径2:");
            List<List<Integer>> findPath4 = binaryTreeList.getSpDeepTree(
                    binaryTreeList.root, 12);
            for (List<Integer> arrayList : findPath4) {
                for (Integer integer : arrayList) {
                    System.out.print(integer + ",");
                }
                System.out.println();
            }
        }
    }