．画出与下列已知序列对应的树Ｔ： 树的先根次序访问序列为GFKDAIEBCHJ； 树的后根次序访问序列为DIAEKFCJHBG。

好的，让我考虑一下。

根据题目中给出的先根次序访问序列，我们可以知道根节点为G。然后，我们可以在后根次序访问序列中找到根节点G，然后把这个序列从根节点处分为左子树和右子树的序列。可以得出：

左子树：DIAEKFCJH
右子树：BG

我们可以根据此时的先根次序访问序列和后根次序访问序列来进一步构造出树的结构。构建过程如下：

1. G 是根节点。
2. 首先考虑左子树，先根次序访问序列中下一个节点是F，后根次序访问序列中F 左侧为左子树，右侧为右子树。因此，F 是左子树的根节点。左子树先根次序访问序列为FKDAIECJH，后根次序访问序列为DIAEKFCJH。在左子树中，根据相同的方法建立出子树。左子树的结构如下：

F
/|\
K D I
/|\ | \
A E C J H

3. 接下来考虑右子树。先根次序访问序列中下一个节点是B，后根次序访问序列中 B 右侧为右子树。因此，B 是右子树的根节点。右子树的先根次序访问序列为B，后根次序访问序列为GJHCFKEIADBG。右子树的结构如下：

B
|
G J H C F K E I A D
|
B

因此，所求的树的结构如下：

G
/ | \
F | B
| \ | |
K D I G
| |
A J
/ \
E H
|
C

希望我的答案对你有所帮助！

相关问题

已知一棵二叉树的便利序列如下画出据此构造的二叉树 中根次序便利序列CDBEGFHANMOLKPQSRJIT 后根次序便利序列 DCGHFEBNOMLSRQPKJTIA

根据中根次序便利序列，我们可以确定二叉树的结构，再根据后根次序便利序列，我们可以确定每个节点的位置。具体步骤如下：

1. 中根次序便利序列为 CDBEGFHANMOLKPQSRJIT。根据中根次序便利序列，我们可以确定根节点为I。将中根次序便利序列分为左子树和右子树两部分：

左子树：CDBEGFHANMOLKPQSR

右子树：JT

2. 后根次序便利序列为DCGHFEBNOMLSRQPKJTIA。根据后根次序便利序列，最后一个节点为根节点I，倒数第二个节点为右子树的节点T。将后根次序便利序列分为左子树和右子树两部分：

左子树：DCGHFEBNOMLSRQPK

右子树：TIA

3. 对于左子树，它的后根次序便利序列为DCGHFEBNOMLSRQPK，最后一个节点为K，倒数第二个节点为Q，因此K为左子树的根节点。将左子树的中根次序便利序列和后根次序便利序列分为左子树和右子树两部分：

左子树：DCGHFEBNOMLSR

右子树：QPK

4. 对于左子树的左子树，它的后根次序便利序列为DCGHFEBNOMLSR，最后一个节点为R，倒数第二个节点为S，因此R为左子树的左子树的根节点。将左子树的左子树的中根次序便利序列和后根次序便利序列分为左子树和右子树两部分：

左子树：DCGHFEBNO

右子树：LSR

5. 对于左子树的左子树的右子树，它的后根次序便利序列为LSR，最后一个节点为R，倒数第二个节点为S，因此R为左子树的左子树的右子树的根节点。将左子树的左子树的右子树的中根次序便利序列和后根次序便利序列分为左子树和右子树两部分：

左子树：L

右子树：SR

6. 对于左子树的左子树的右子树的右子树，它的后根次序便利序列为SR，最后一个节点为R，倒数第二个节点为S，因此R为左子树的左子树的右子树的右子树的根节点。

7. 对于左子树的右子树，它的后根次序便利序列为QPK，最后一个节点为K，倒数第二个节点为P，因此K为左子树的右子树的根节点。将左子树的右子树的中根次序便利序列和后根次序便利序列分为左子树和右子树两部分：

左子树：Q

右子树：PK

8. 对于左子树的右子树的右子树，它的后根次序便利序列为PK，最后一个节点为K，倒数第二个节点为P，因此K为左子树的右子树的右子树的根节点。

9. 对于右子树，它的后根次序便利序列为TIA，最后一个节点为A，倒数第二个节点为I，因此A为右子树的根节点。将右子树的中根次序便利序列和后根次序便利序列分为左子树和右子树两部分：

左子树：T

右子树：I

因此，据此构造的二叉树如下图所示：

         I
       /   \
      /     \
     K       A
  /     \       \
 C       Q       T
  \             /
   E           J
  / \         / \
 D   G       M   S
          /   \
         B     R
                \
                 P

Java代码实现创建一棵二叉链表表示的二叉树中，实现1.输入叶子结点、2.求二叉树中叶子结点个数、3.将每个结点的左子树与右子树交换、4.验证二叉树的性质3：n0=n2+1、5.输出值大于k的结点、6.已知先根和中根次序遍历序列构造二叉树、7.以广义表表示构造二叉树、8.判断两颗二叉树是否相等、9.求结点所在的层次、10.求一颗二叉树在后根次序遍历下第一个访问的结点、11.复制一颗二叉树、12.判断一颗二叉树是否为完全二叉树、13.实现二叉树后根次序遍历的非递归算法的操作，并每一个操作分别采用先根、中根、后根、层次遍历算法

好的，我会尽力回答你的问题。以下是对你提出的Java二叉树问题的回答：

1. 输入叶子节点
首先，我们需要定义节点类：

class Node {
    int value;
    Node left;
    Node right;
    public Node(int value) {
        this.value = value;
    }
}

然后，我们可以通过递归的方式生成二叉树：

public Node createTree(Scanner scanner) {
    System.out.println("请输入节点值：");
    int value = scanner.nextInt();
    if (value == 0) {
        return null;
    }
    Node node = new Node(value);
    node.left = createTree(scanner);
    node.right = createTree(scanner);
    return node;
}

2. 求二叉树中叶子结点个数
我们可以通过递归的方式遍历二叉树，统计叶子节点的个数：

public int countLeafNodes(Node node) {
    if (node == null) {
        return 0;
    }
    if (node.left == null && node.right == null) {
        return 1;
    }
    return countLeafNodes(node.left) + countLeafNodes(node.right);
}

3. 将每个结点的左子树与右子树交换
我们可以通过递归的方式遍历二叉树，交换每个节点的左右子树：

public void swapLeftRight(Node node) {
    if (node == null) {
        return;
    }
    Node temp = node.left;
    node.left = node.right;
    node.right = temp;
    swapLeftRight(node.left);
    swapLeftRight(node.right);
}

4. 验证二叉树的性质3：n0=n2+1
我们可以通过递归的方式遍历二叉树，统计叶子节点和度为2的节点的个数，然后判断它们是否符合性质3：

public boolean verifyPropertyThree(Node node) {
    int leafNodes = countLeafNodes(node);
    int degreeTwoNodes = countDegreeTwoNodes(node);
    return leafNodes == degreeTwoNodes + 1;
}

public int countDegreeTwoNodes(Node node) {
    if (node == null) {
        return 0;
    }
    if (node.left != null && node.right != null) {
        return countDegreeTwoNodes(node.left) + countDegreeTwoNodes(node.right) + 1;
    }
    return countDegreeTwoNodes(node.left) + countDegreeTwoNodes(node.right);
}

5. 输出值大于k的结点
我们可以通过递归的方式遍历二叉树，输出值大于k的节点：

public void printNodesGreaterThanK(Node node, int k) {
    if (node == null) {
        return;
    }
    if (node.value > k) {
        System.out.print(node.value + " ");
    }
    printNodesGreaterThanK(node.left, k);
    printNodesGreaterThanK(node.right, k);
}

6. 已知先根和中根次序遍历序列构造二叉树
我们可以通过递归的方式构造二叉树，先根次序遍历的第一个节点是根节点，然后在中根次序遍历中找到根节点的位置，将序列分为左右两部分，分别构造左右子树：

public Node buildTree(int[] preOrder, int[] inOrder, int preStart, int preEnd, int inStart, int inEnd) {
    if (preStart > preEnd || inStart > inEnd) {
        return null;
    }
    int rootValue = preOrder[preStart];
    Node root = new Node(rootValue);
    int rootIndex = -1;
    for (int i = inStart; i <= inEnd; i++) {
        if (inOrder[i] == rootValue) {
            rootIndex = i;
            break;
        }
    }
    int leftSize = rootIndex - inStart;
    root.left = buildTree(preOrder, inOrder, preStart + 1, preStart + leftSize, inStart, rootIndex - 1);
    root.right = buildTree(preOrder, inOrder, preStart + leftSize + 1, preEnd, rootIndex + 1, inEnd);
    return root;
}

7. 以广义表表示构造二叉树
我们可以通过递归的方式构造二叉树，广义表的表示方法是：(root,left,right)，其中left和right都是广义表的形式：

public Node buildTree(String str) {
    if (str == null || str.length() == 0) {
        return null;
    }
    int firstCommaIndex = str.indexOf(",");
    int value = Integer.parseInt(str.substring(1, firstCommaIndex));
    Node root = new Node(value);
    int secondCommaIndex = findSecondCommaIndex(str);
    root.left = buildTree(str.substring(firstCommaIndex + 1, secondCommaIndex));
    root.right = buildTree(str.substring(secondCommaIndex + 1, str.length() - 1));
    return root;
}

private int findSecondCommaIndex(String str) {
    int count = 0;
    for (int i = 1; i < str.length() - 1; i++) {
        if (str.charAt(i) == '(') {
            count++;
        } else if (str.charAt(i) == ')') {
            count--;
        } else if (str.charAt(i) == ',' && count == 0) {
            return i;
        }
    }
    return -1;
}

8. 判断两颗二叉树是否相等
我们可以通过递归的方式比较两棵二叉树是否相等：

public boolean isSameTree(Node p, Node q) {
    if (p == null && q == null) {
        return true;
    }
    if (p == null || q == null) {
        return false;
    }
    if (p.value != q.value) {
        return false;
    }
    return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}

9. 求结点所在的层次
我们可以通过递归的方式求出结点所在的层次：

public int getNodeLevel(Node node, Node target, int level) {
    if (node == null) {
        return 0;
    }
    if (node == target) {
        return level;
    }
    int leftLevel = getNodeLevel(node.left, target, level + 1);
    if (leftLevel != 0) {
        return leftLevel;
    }
    int rightLevel = getNodeLevel(node.right, target, level + 1);
    return rightLevel;
}

10. 求一颗二叉树在后根次序遍历下第一个访问的结点
我们可以通过递归的方式求出在后根次序遍历下第一个访问的结点：

public Node getFirstVisitNode(Node node) {
    if (node == null) {
        return null;
    }
    Node left = getFirstVisitNode(node.left);
    Node right = getFirstVisitNode(node.right);
    if (left == null && right == null) {
        return node;
    }
    if (right == null) {
        return left;
    }
    if (left == null) {
        return right;
    }
    return node;
}

11. 复制一颗二叉树
我们可以通过递归的方式复制一颗二叉树：

public Node cloneTree(Node node) {
    if (node == null) {
        return null;
    }
    Node clone = new Node(node.value);
    clone.left = cloneTree(node.left);
    clone.right = cloneTree(node.right);
    return clone;
}

12. 判断一颗二叉树是否为完全二叉树
我们可以通过层次遍历的方式判断一颗二叉树是否为完全二叉树：

public boolean isCompleteTree(Node node) {
    Queue<Node> queue = new LinkedList<>();
    queue.offer(node);
    boolean nullNodeAppeared = false;
    while (!queue.isEmpty()) {
        Node current = queue.poll();
        if (current == null) {
            nullNodeAppeared = true;
        } else {
            if (nullNodeAppeared) {
                return false;
            }
            queue.offer(current.left);
            queue.offer(current.right);
        }
    }
    return true;
}

13. 实现二叉树后根次序遍历的非递归算法的操作，并每一个操作分别采用先根、中根、后根、层次遍历算法
我们可以使用栈的方式实现后根次序遍历的非递归算法，先根、中根、层次遍历的非递归算法也可以使用栈或队列实现：

// 后根次序遍历的非递归算法
public void postOrderTraversal(Node node) {
    Stack<Node> stack1 = new Stack<>();
    Stack<Node> stack2 = new Stack<>();
    stack1.push(node);
    while (!stack1.isEmpty()) {
        Node current = stack1.pop();
        stack2.push(current);
        if (current.left != null) {
            stack1.push(current.left);
        }
        if (current.right != null) {
            stack1.push(current.right);
        }
    }
    while (!stack2.isEmpty()) {
        System.out.print(stack2.pop().value + " ");
    }
}

// 先根次序遍历的非递归算法
public void preOrderTraversal(Node node) {
    Stack<Node> stack = new Stack<>();
    stack.push(node);
    while (!stack.isEmpty()) {
        Node current = stack.pop();
        System.out.print(current.value + " ");
        if (current.right != null) {
            stack.push(current.right);
        }
        if (current.left != null) {
            stack.push(current.left);
        }
    }
}

// 中根次序遍历的非递归算法
public void inOrderTraversal(Node node) {
    Stack<Node> stack = new Stack<>();
    Node current = node;
    while (current != null || !stack.isEmpty()) {
        while (current != null) {
            stack.push(current);
            current = current.left;
        }
        current = stack.pop();
        System.out.print(current.value + " ");
        current = current.right;
    }
}

// 层次遍历的非递归算法
public void levelOrderTraversal(Node node) {
    Queue<Node> queue = new LinkedList<>();
    queue.offer(node);
    while (!queue.isEmpty()) {
        Node current = queue.poll();
        System.out.print(current.value + " ");
        if (current.left != null) {
            queue.offer(current.left);
        }
        if (current.right != null) {
            queue.offer(current.right);
        }
    }
}