【Java数据结构 -- 二叉树+树的深度优先遍历】

1. 二叉树

1.1 二叉树的介绍

二叉树是一种数据结构，一颗二叉树是节点的集合，即每个节点最多有两个子节点，分别为左子节点和右子节点。二叉树可以为空，或者是由一个根节点 和两个指向左子树和右子树的指针。

1.2 两种特殊的二叉树

1. 满二叉树：每层的节点数都达到最大值，则该二叉树就是满二叉树 ，即如果一颗二叉树的层数为K，且节点总数是2^k - 1，则它是满二叉树。
2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

1.3 二叉树的性质

1. 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有2^i -1（i>0）个结点；
2. 若规定只有根结点的二叉树的深度为1，则深度为k的二叉树的最大结点数是2^k -1(k>=0)；
3. 对任何一颗二叉树，如果叶结点个数为n0，度为2的非叶子结点个数为n2，则有n0 = n2+1；
4. 具有n个结点的完全二叉树，如果按照从上至下，从左至右的顺序对所有结点从0开始编号，则对于序号为i的结点有：

• ** 若i>0，双亲序号：(i-2)/2；i = 0，i为根结点编号**，无双亲结点
• 若2i+1<n,左孩子序号：2i+1,否则无左孩子
• 若2i+2<n,右孩子序号：2i+2，否则无右孩子

1.4 二叉树的存储

二叉树的存储结构分为：顺序存储（即堆）和类似于链表的链式存储。
二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式（一般用孩子表示法）：

// 孩子表示法
class Node {
	int val; // 数据域
	Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
	Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
}
// 孩子双亲表示法
class Node {
	int val; // 数据域
	Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
	Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
	Node parent; // 当前节点的根节点
}

2. 二叉树的基本操作

2.1 二叉树的创建

创建一个如下的二叉树

public class BinaryTree {
    static class TreeNode {
        public char val;
        public TreeNode left;
        public TreeNode right;


        public TreeNode(char val) {
            this.val = val;
        }
    }

    //public TreeNode root;
    //创建二叉树  创建成功后  返回根节点
    public TreeNode createTree() {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');

        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        C.left = F;
        C.right = G;
        E.right = H;

        return A;
    }
}

2.2 二叉树的优先遍历

二叉树的优先遍历是指按照一定顺序访问二叉树中的所有节点。常见的三种优先遍历方式包括：前序遍历、中序遍历和后序遍历。可以使用递归实现、非递归实现这三种遍历方式。

• NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点—>根的左子树—>根的右子树，即根-左-右。
• LNR：中序遍历(Inorder Traversal)——根的左子树—>根节点—>根的右子树，即左-根-右。
• LRN：后序遍历(Postorder Traversal)——根的左子树—>根的右子树—>根节点，即左-右-根。

2.3 递归实现二叉树遍历

• 前序遍历：上图该二叉树的前序遍历为：A B D E H C F G
  思路：在递归之前先打印当前根结点的值，然后向左子树递出，每一次都需要对当前结点的值访问，直到node为null时，左子树结束递出。当右子树此时也为node==null，从叶子结点开始回归，回归到上一个结点的右子树。

void preOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        System.out.print(root.val+"");
        preOrder(root.left);
        preOrder(root.right);
    }

• 中序遍历：D B E H A F C G
  思路：向左子树递出，一直下去，直到node 为null 时，左子树结束递出。再来对当前节点的值进行访问，接着继续向着右子树递出，当右子树此时也为 node == null 时，从叶子节点开始回归，回归到上一个节点的右子树前先对当前节点的值进行访问。

// 中序 ： 左 根 右
    void inOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.print(root.val+"");
        inOrder(root.right);
    }

• 后序遍历：D H E B F G C A
  向左子树递出，一直下去，直到 node 为 null 时，左子树结束递出。再接着继续向着右子树递出，再来对当前节点的值进行访问，当右子树此时也为 node 为 null 时，从叶子节点开始回归，回归到对当前节点的值进行访问

// 后序 ： 左 右  根
    void postOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val+"");
    }

2.4 用非递归实现二叉树遍历

• 非递归前序遍历：
  思路：给一个栈（先进后出），遍历二叉树，或者栈不为空时，定义一个cur一直往左走，放入栈中再进行打印，之后再让top记录栈顶，让cur指向top的右子树。

void preOrderNor(TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;

        while (cur != null || !stack.isEmpty()) {
            while (cur != null) {
                stack.push(cur);
                System.out.print(cur.val+" ");
                cur = cur.left;
            }
            TreeNode top = stack.pop();
            cur = top.right;
        }
    }

• 非递归中序遍历：
  思路：给一个栈（先进后出），遍历二叉树，或者栈不为空时，定义一个cur一直往左走，放入栈中，等走完左子树弹出栈顶元素给top，再进行打印，最后让cur指向top的右子树即遍历弹出节点的右子树。

void inOrderNor(TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;

        while (cur != null || !stack.isEmpty()) {
            while(cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            TreeNode top = stack.pop();
            System.out.print(top.val + " ");
            cur = top.right;
        }

    }

• 非递归后序遍历：
  思路：给一个栈（先进后出），遍历二叉树，或者栈不为空时，定义一个prev，定义一个cur一直往左走，让top指向栈顶元素；如果右子树为空或者右边已经打印完了，执行：打印栈顶元素，再出栈，让prev指向top，然后让cur指向top右子树。

void postOrderNor(TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        TreeNode prev = null;

        while (cur != null || !stack.isEmpty()) {
            while(cur != null) {
                stack.push(cur);
                cur = cur.left;
            }

            TreeNode top = stack.peek();
            if (top.right == null || top.right == prev) {
                System.out.print(top.val + " ");
                stack.pop();
                prev = top;     //记录下最新被打印的那个节点
            }else {
                cur = top.right;
            }
        }

    }