ACM构建二叉树

如何构造二叉树用例？

从二叉树 推导到 序列，大家可以发现这就是层序遍历。

从序列 推导到 二叉树，就是构造二叉树。

如果父节点的数组下标是i，那么它的左孩子下标就是i * 2 + 1，右孩子下标就是 i * 2 + 2。

序列构造二叉树

// 根据数组构造二叉树
TreeNode* construct_binary_tree(const vector<int>& vec) {
    vector<TreeNode*> vecTree (vec.size(), NULL);
    //根节点指针
    TreeNode* root = NULL;
    // 把输入数值数组，先转化为二叉树节点数组
    for (int i = 0; i < vec.size(); i++) {
        TreeNode* node = NULL;
        if (vec[i] != -1) node = new TreeNode(vec[i]); // 用 -1 表示null
        vecTree[i] = node;
        if (i == 0) root = node;
    }
    // 遍历一遍，根据规则左右孩子赋值就可以了
    // 注意这里 结束规则是 i * 2 + 2 < vec.size()，避免空指针
    for (int i = 0; i * 2 + 2 < vec.size(); i++) {
        if (vecTree[i] != NULL) {
            // 线性存储转连式存储关键逻辑
            vecTree[i]->left = vecTree[i * 2 + 1];
            vecTree[i]->right = vecTree[i * 2 + 2];
        }
    }
    return root;
}

层序打印二叉树

// 层序打印打印二叉树
void print_binary_tree(TreeNode* root) {
    queue<TreeNode*> que;
    if (root != NULL) que.push(root);
    vector<vector<int>> result;
    while (!que.empty()) {
        int size = que.size();
        vector<int> vec;
        for (int i = 0; i < size; i++) {
            TreeNode* node = que.front();
            que.pop();
            if (node != NULL) {
                vec.push_back(node->val);
                que.push(node->left);
                que.push(node->right);
            }
            // 这里的处理逻辑是为了把null节点打印出来，用-1 表示null
            else vec.push_back(-1);
        }
        result.push_back(vec);
    }
    for (int i = 0; i < result.size(); i++) {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j] << " ";
        }
        cout << endl;
    }
}

完整代码

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

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 根据数组构造二叉树
TreeNode* construct_binary_tree(const vector<int>& vec) {
    vector<TreeNode*> vecTree (vec.size(), NULL);
    TreeNode* root = NULL;
    for (int i = 0; i < vec.size(); i++) {
        TreeNode* node = NULL;
        if (vec[i] != -1) node = new TreeNode(vec[i]);
        vecTree[i] = node;
        if (i == 0) root = node;
    }
    for (int i = 0; i * 2 + 2 < vec.size(); i++) {
        if (vecTree[i] != NULL) {
            vecTree[i]->left = vecTree[i * 2 + 1];
            vecTree[i]->right = vecTree[i * 2 + 2];
        }
    }
    return root;
}

// 层序打印打印二叉树
void print_binary_tree(TreeNode* root) {
    queue<TreeNode*> que;
    if (root != NULL) que.push(root);
    vector<vector<int>> result;
    while (!que.empty()) {
        int size = que.size();
        vector<int> vec;
        for (int i = 0; i < size; i++) {
            TreeNode* node = que.front();
            que.pop();
            if (node != NULL) {
                vec.push_back(node->val);
                que.push(node->left);
                que.push(node->right);
            }
            // 这里的处理逻辑是为了把null节点打印出来，用-1 表示null
            else vec.push_back(-1);
        }
        result.push_back(vec);
    }
    for (int i = 0; i < result.size(); i++) {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    // 注意本代码没有考虑输入异常数据的情况
    // 用 -1 来表示null
    vector<int> vec = {4,1,6,0,2,5,7,-1,-1,-1,3,-1,-1,-1,8};
    TreeNode* root = construct_binary_tree(vec);
    print_binary_tree(root);
}

自己的代码

#include <iostream> 
#include <queue>
#include <vector>
using namespace std;
/*二叉树节点*/
struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
//构造二叉树
class binaryTree
{
public:
	binaryTree();
	~binaryTree();
	TreeNode* constructBinaryTree(const vector<int> &vec);
	void printBinaryTree(TreeNode* node);
};

binaryTree::binaryTree()
{
}

binaryTree::~binaryTree()
{
}
TreeNode* binaryTree::constructBinaryTree(const vector<int> &vec) {
	TreeNode* root = NULL;
	//将序列变成节点数组
	vector<TreeNode*> treeNodeArray;
	for (int i = 0; i < vec.size(); i++) {
		TreeNode* node = NULL;
		if (vec[i] != -1) node = new TreeNode(vec[i]);
		if (i == 0) root = node;;
		treeNodeArray.push_back(node);
	}
	/*
		将节点建立连接关系
		left = parent*2 + 1
		right = parent*2 + 2
	*/
	for (int i = 0; i * 2 + 2 < treeNodeArray.size(); i++) {
		if (treeNodeArray[i] != NULL) {
			treeNodeArray[i]->left = treeNodeArray[i * 2 + 1];
			treeNodeArray[i]->right = treeNodeArray[i * 2 + 2];
		}
	}
	return root;
}
//打印二叉树
void binaryTree::printBinaryTree(TreeNode* node) {
	queue<TreeNode*> que;
	if (node != NULL) que.push(node);
	while (!que.empty()) {
		int size = que.size();
		for (int i = 0; i < size; i++) {
			TreeNode* node = que.front();
			que.pop();
			if (node == NULL) cout << "-1"<<" ";
			else {
				cout << node->val << " ";
				que.push(node->left);
				que.push(node->right);
			}
		}
		cout << endl;
	}
}
int main() {
	//用 -1 表示 NULL
	vector<int> vec = { 4,1,6,0,2,5,7,-1,-1,-1,3,-1,-1,-1,8 };
	binaryTree* ptr = new binaryTree;
	TreeNode* root = ptr->constructBinaryTree(vec);
	ptr->printBinaryTree(root);
	return 0;
}