1、链表实现二叉树

// 树节点类
class Bitreenode {
    char data;
    Bitreenode* ls, * rs, * fa;  // ls为左儿子节点，rs为右儿子节点，fa为父节点
public:
    Bitreenode() {
        data = '0';
        ls = rs = fa = nullptr;
    }
    void set_ls(Bitreenode *p) {
        ls = p;
    }
    void set_rs(Bitreenode* p) {
        rs = p;
    }
    void set_data(char d) {
        data = d;
    }
    void set_fa(Bitreenode* p) {
        fa = p;
    }
    char get_data() {
        return data;
    }
    Bitreenode* get_ls() {
        return ls;
    }
    Bitreenode*  get_rs() {
        return rs;
    }
    Bitreenode* get_fa() {
        return fa;
    }
};

string s;  
int pos;
char son[100];
char fa[100];

class Bitree {
    Bitreenode* root;
    int num;
    int cnt;
    int h;
public:

    // 建树前初始化工作
    void Creat() {
        pos = 0;
        num = 0;
        cnt = 0;
        h = 0;
        root = creat_tree(nullptr, 0);
    }
    
    // 建树方法采用“先序遍历+空树用0表示”的方法
    Bitreenode* creat_tree(Bitreenode * fa, int height) {
        Bitreenode* cn;
        if (pos >= s.size()) {
            return nullptr;
        }
        char ch = s[pos];
        if (ch == '0') {
            pos++;
            cn = nullptr;
        }
        else {
            height++;
            h = max(h, height);
            cn = new Bitreenode;
            cn->set_data(ch);
            cn->set_fa(fa);
            num++;
            pos++;
            cn->set_ls(creat_tree(cn, height));
            cn->set_rs(creat_tree(cn, height));
        }
        return cn;
    }

    // 前序遍历
    void preOrder(Bitreenode *p) {
        if (p != nullptr) {
            cout << p->get_data();
            preOrder(p->get_ls());
            preOrder(p->get_rs());
        }
    }

    // 中序遍历
    void inOrder(Bitreenode* p) {
        if (p != nullptr) {
            inOrder(p->get_ls());
            cout << p->get_data();
            inOrder(p->get_rs());
        }
    }

    // 后序遍历
    void posOrder(Bitreenode* p) {
        if (p != nullptr) {
            posOrder(p->get_ls());
            posOrder(p->get_rs());
            cout << p->get_data();
        }
    }

    // 计算叶节点数
    int get_sonnode(Bitreenode *p) {
        if (p != nullptr) {
            if (p->get_ls() == nullptr && p->get_rs() == nullptr) {
                son[cnt] = p->get_data();
                fa[cnt] = p->get_fa()->get_data();
                cnt++;
            }
            else {
                get_sonnode(p->get_ls());
                get_sonnode(p->get_rs());
            }
        }
        return cnt;
    }

    // 层序遍历
    void levelOrder(Bitreenode* p) {
        queue<Bitreenode*> q;
        if (p == nullptr) {
            return;
        }
        q.push(p);
        while (q.empty() != 1) {
            p = q.front();
            q.pop();
            cout << p->get_data();
            if (p->get_ls() != nullptr) {
                q.push(p->get_ls());
            }
            if (p->get_rs() != nullptr) {
                q.push(p->get_rs());
            }
            
        }
    }
    
    // 返回根节点
    Bitreenode* get_root() {
        return root;
    }

    // 返回树的深度
    int get_h() {
        return h;
    }
};

2、数组实现二叉树

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include<queue>
using namespace std;

struct Bitree {
	int data;
	int ls;
	int rs;
};

void preOrder(Bitree * p, int n, int pos) {
	if(p[pos].data != 0) {
		cout << p[pos].data << " ";
		if(p[pos].ls != -1)preOrder(p, n, p[pos].ls);
		if(p[pos].rs != -1)preOrder(p, n, p[pos].rs);
	}
}

int main() {
	int t;
	cin >> t;
	while (t--) {
		int n;
		cin >> n;
		Bitree* p = new Bitree[n + 1];
		for (int i = 1; i <= n; i++) {
			cin >> p[i].data;
			if (2 * i <= n) {
				p[i].ls = 2 * i;
			}
			else p[i].ls = -1;

			if (2 * i + 1 <= n) {
				p[i].rs = 2 * i + 1;
			}
			else p[i].rs = -1;
		}
		preOrder(p, n, 1);
		cout << endl;
	}
	return 0;
}