A (1)
       /      \
     B(2)     C(3)
    /   \    /
   D(4) E(5) F(6)

         A
       /   \
      B     C
       \   / \
        D E   F

#include <iostream>
#include <vector>
using namespace std;

class CompleteBinaryTree {
private:
    vector<char> tree;   // 存储节点的数组，下标0不用
    int n;               // 节点总数

public:
    // 构造函数：传入按层序排列的节点值列表
    CompleteBinaryTree(const vector<char>& values) {
        n = values.size();
        tree.resize(n + 1);            // tree[0] 空着不用
        for (int i = 0; i < n; ++i) {
            tree[i + 1] = values[i];   // 把values[i]放到下标i+1
        }
    }

    // 获取下标i的节点的左孩子下标，不存在返回-1
    int leftChild(int i) {
        int lc = 2 * i;
        return (lc <= n) ? lc : -1;
    }

    // 获取右孩子下标
    int rightChild(int i) {
        int rc = 2 * i + 1;
        return (rc <= n) ? rc : -1;
    }

    // 获取父节点下标，根节点返回-1
    int parent(int i) {
        if (i == 1) return -1;   // 根节点没有父节点
        return i / 2;            // 整数除法
    }

    // 获取节点值，如果下标越界返回'?'
    char get(int i) {
        if (i < 1 || i > n) return '?';
        return tree[i];
    }

    // 打印数组内容
    void print() {
        cout << "数组存储(下标从1): ";
        for (int i = 1; i <= n; ++i) {
            cout << tree[i] << " ";
        }
        cout << endl;
    }
};

int main() {
    // 构造一个完全二叉树，节点为 A,B,C,D,E,F
    vector<char> values = {'A', 'B', 'C', 'D', 'E', 'F'};
    CompleteBinaryTree cbt(values);
    cbt.print();

    cout << "根节点: " << cbt.get(1) << endl;
    cout << "左孩子(下标2): " << cbt.get(cbt.leftChild(1)) << endl;
    cout << "右孩子(下标3): " << cbt.get(cbt.rightChild(1)) << endl;
    cout << "节点B(下标2)的父节点: " << cbt.get(cbt.parent(2)) << endl;
    cout << "节点C(下标3)的左孩子(下标6): " << cbt.get(cbt.leftChild(3)) << endl;
    cout << "节点C的右孩子下标: " << cbt.rightChild(3) << " (不存在，返回-1)" << endl;
    return 0;
}

数组存储(下标从1): A B C D E F 
根节点: A
左孩子(下标2): B
右孩子(下标3): C
节点B(下标2)的父节点: A
节点C(下标3)的左孩子(下标6): F
节点C的右孩子下标: -1 (不存在，返回-1)

class CompleteBinaryTree:
    def __init__(self, values):
        # values: 按层序排列的节点值列表
        self.n = len(values)
        self.tree = [None] * (self.n + 1)   # tree[0] 闲置
        for i in range(self.n):
            self.tree[i + 1] = values[i]

    def left_child(self, i):
        lc = 2 * i
        return lc if lc <= self.n else -1

    def right_child(self, i):
        rc = 2 * i + 1
        return rc if rc <= self.n else -1

    def parent(self, i):
        if i == 1:
            return -1
        return i // 2   # 整数除法

    def get(self, i):
        if 1 <= i <= self.n:
            return self.tree[i]
        return '?'

    def print_tree(self):
        print("数组存储(下标从1):", self.tree[1:])

# 测试
values = ['A', 'B', 'C', 'D', 'E', 'F']
cbt = CompleteBinaryTree(values)
cbt.print_tree()
print("根节点:", cbt.get(1))
print("左孩子(下标2):", cbt.get(cbt.left_child(1)))
print("右孩子(下标3):", cbt.get(cbt.right_child(1)))
print("节点B(下标2)的父节点:", cbt.get(cbt.parent(2)))
print("节点C(下标3)的左孩子(下标6):", cbt.get(cbt.left_child(3)))
print("节点C的右孩子下标:", cbt.right_child(3), "(不存在)")