UGC-NET | UGC NET CS 2018 七月 – II |第 70 题

该问题涉及到基础的数据结构知识，主要是二叉树的遍历。

题目描述

假设 T 为一棵二叉树，其中左右子树可能为空。对于任意结点 root，若它的左子树不为空，则它的左子树上最右端的值为 root 的前驱；若它的右子树不为空，则它的右子树上最左端的值为 root 的后继。现给出一棵二叉树的中序遍历结果，求其中每个结点的前驱和后继。

解题思路

首先，对于中序遍历的结果，我们可以通过递归构建二叉树的方式来实现建树。其次，对于每个结点，我们可以通过分别遍历其左右子树，找到其前驱和后继。为了避免重复遍历，可以使用一个 Map 存储每个结点的对应前驱和后继的值。

代码实现

import java.util.HashMap;
import java.util.Map;

public class BinarySearchTree {

    private Node root;
    private Map<Node, Node> predecessorMap;
    private Map<Node, Node> successorMap;

    public void add(int value) {
        root = add(root, value);
    }

    private Node add(Node node, int value) {
        if (node == null) {
            return new Node(value);
        }
        if (value < node.value) {
            node.left = add(node.left, value);
        } else if (value > node.value) {
            node.right = add(node.right, value);
        }
        return node;
    }

    public void inOrderTraversal() {
        predecessorMap = new HashMap<>();
        successorMap = new HashMap<>();
        inOrderTraversal(root, null);
        for (Node node : predecessorMap.keySet()) {
            Node predecessor = predecessorMap.get(node);
            System.out.print(predecessor != null ? predecessor.value : "null");
            System.out.print(" " + node.value + " ");
            Node successor = successorMap.get(node);
            System.out.println(successor != null ? successor.value : "null");
        }
    }

    private void inOrderTraversal(Node node, Node parent) {
        if (node != null) {
            inOrderTraversal(node.left, node);
            if (node.left != null) {
                predecessorMap.put(node, getMax(node.left));
            } else {
                predecessorMap.put(node, parent);
            }
            if (node.right != null) {
                successorMap.put(node, getMin(node.right));
            } else {
                successorMap.put(node, parent);
            }
            inOrderTraversal(node.right, node);
        }
    }

    private Node getMax(Node node) {
        while (node.right != null) {
            node = node.right;
        }
        return node;
    }

    private Node getMin(Node node) {
        while (node.left != null) {
            node = node.left;
        }
        return node;
    }

    private static class Node {
        int value;
        Node left;
        Node right;

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

}

该算法的时间复杂度为 O(n)，空间复杂度为 O(n) （递归栈空间和 HashMap）。因此，如果二叉树的高度较大，可能会导致栈溢出。如果需要处理超大数据集，可以考虑使用非递归实现。