2.1己知一棵完全二叉树按顺序方式存储在数组int A[1..n]中。设计算法，求出下标分别为i和j（i <=n，j <=n）的两个结点的最近的公共祖先结点的位置和值。

这道题可以使用完全二叉树的性质来解决。设节点i的父节点为p，左儿子为l，右儿子为r，则有以下性质：

1. 如果i是左儿子，则p = i / 2。
2. 如果i是右儿子，则p = (i - 1) / 2。
3. 如果i是叶子节点，则l = 2 * i，r = 2 * i + 1。

因此，我们可以从节点i一直往上找到根节点，记录路径上的节点位置和值。同样，也可以从节点j一直往上找到根节点，记录路径上的节点位置和值。然后从两条路径的末尾开始往前找，找到最后一个相同的节点，即为它们的最近公共祖先。

具体算法步骤如下：

1. 如果i或j超出了数组范围，返回null。
2. 从节点i开始往上找，记录路径上的节点位置和值，直到找到根节点。
3. 从节点j开始往上找，记录路径上的节点位置和值，直到找到根节点。
4. 从两条路径的末尾开始往前找，找到最后一个相同的节点。
5. 返回最近公共祖先的位置和值。

以下是算法的Java实现代码：

public class LowestCommonAncestor {
    public static int[] findLCA(int[] A, int i, int j) {
        if (i > A.length || j > A.length) {
            return null;
        }
        int[] pathI = new int[A.length];
        int[] pathJ = new int[A.length];
        int indexI = 0, indexJ = 0;
        // 从节点i开始往上找，记录路径上的节点位置和值
        while (i > 0) {
            pathI[indexI++] = i;
            i = i / 2;
        }
        // 从节点j开始往上找，记录路径上的节点位置和值
        while (j > 0) {
            pathJ[indexJ++] = j;
            j = j / 2;
        }
        // 从两条路径的末尾开始往前找，找到最后一个相同的节点
        int pos = -1, value = -1;
        while (indexI >= 0 && indexJ >= 0) {
            if (pathI[indexI] == pathJ[indexJ]) {
                pos = pathI[indexI];
                value = A[pos];
            }
            indexI--;
            indexJ--;
        }
        return new int[] {pos, value};
    }

    public static void main(String[] args) {
        int[] A = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        int[] result = findLCA(A, 4, 8);
        System.out.println("Position: " + result[0] + ", Value: " + result[1]); // Position: 2, Value: 2
    }
}