二叉树代码，见下

#include <iostream>
using namespace std;

template<typename T>
struct TreeNode{
	T val;
	TreeNode *left;
	TreeNode *right;
	TreeNode():val(0), left(NULL), right(NULL)
	TreeNode(T x):val(x), left(NULL), right(NULL){}
};

template<typename T>
class Tree(){
private:
	TreeNode<T> *nodes;
	TreeNode<T> *root;
	size_t nodeSize;
	
	TreeNode<T> *Create(T a[], int size, int nodeId, T nullNode);
	void visit(TreeNode<T> *node);
	void preOrder(TreeNode<T> *node);
	void inOrder(TreeNode<T> *node);
	void postOrder(TreeNode<T> *node);
	void levelOrder(TreeNode<T> *node);
public:
	Tree();
	Tree(int maxNodes);
	~Tree();
	TreeNode<T>* GetTreeNode(int id);
	void CreateTree(T a[], int size, T nullNode);
	void preOrderTraversal();
	void inOrderTraversal();
	void postOrderTraversal();	
};

template<typename T>
Tree<T>::Tree(){
	nodeSize = 100001;
	nodes = new TreeNode<T>[nodeSize]
}

template<typename T>
Tree<T>::Tree(int maxNodes){
	nodeSize = maxNodes;
	nodes = new TreeNode<T>[nodeSize];
}

template<typename T>
TreeNode<T>* Tree<T>::GetTreeNode(int id){
	return &nodes[id];
}

template<typename T>
void Tree<T>::visit(TreeNode<T> *node){
	cout << node->val;
}

template<typename T>
void Tree<T>::preOrder(TreeNode<T> *node){
	if(node){
		visit(node);
		preOrder(node->left);
		preOrder(node->right);
	}
}

template<typename T>
void Tree<T>::inOrder(TreeNode<T> *node){
	if(node){
		inOrder(node->left);
		visit(node);
		inOrder(node->right);
	}
}


template<typename T>
void Tree<T>::postOrder(TreeNode<T> *node){
	if(node){
		postOrder(node->left);
		postOrder(node->right);
		visit(node);
	}
}

template<typename T>
void Tree<T>::CreatTree(T a[], int size, T nullnode){
	root = Create(a, size, 1, nullnode);
}

template<typename T>
TreeNode<T>* Tree<T>::Create(T a[], int size, int nodeId, T nullnode){
	if(nodeId >= size || a[nodeId] == nullnode){
		return NULL;
	}
	TreeNode<T> *nowNode = GetTreeNode(nodeId);
	nowNode->val = a[nodeId];
	nowNode->left = Create(a, size, nodeId*2, nullnode);
	nowNode->right = Create(a, size, nodeId*2+1, nullnode);
	return nownode;	
}

template<typename T>
void Tree<T>::preOrderTraversal(){
	preOrder(root);
}

template<typename T>
void Tree<T>::inOrderTraversal(){
	inOrder(root);
}

template<typename T>
void Tree<T>::postOrderTraversal(){
	postOrder(root);
}
int main()
{
   cout << "Hello World";
   return 0;
}

二叉树代码，对应力扣，完全二叉树的节点个数

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root == NULL){
            return 0;
        }
        int lc = countNodes(root->left);
        int rc = countNodes(root->right);

        return lc + rc + 1;
    }
};

代码练习，对应力扣单值二叉树，代码见下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isUnivalTree(TreeNode* root) {
        if(root == NULL){
            return true;
        }
        if(root->left){
            if(root->val != root->left->val){
                return false;
            }
            if(!isUnivalTree(root->left)){
                return false;
            }
        }
        if(root->right){
            if(root->val != root->right->val){
                return false;
            }
            if(!isUnivalTree(root->right)){
                return false;
            }
        }
        return true;
    }
};

代码四，对应力扣 二叉树的前序遍历，代码见下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> ret;
    void preorder(TreeNode *root){
        if(root){
            ret.push_back(root->val);
            preorder(root->left);
            preorder(root->right);
        }
    }
    vector<int> preorderTraversal(TreeNode* root) {
        ret.clear();
        preorder(root);
        return ret;
    }
};

代码五，对应力扣，二叉树的中序遍历，代码见下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> ret;
    void inorder(TreeNode *root){
        if(root){
            inorder(root->left);
            ret.push_back(root->val);
            inorder(root->right);
        }
    }
    vector<int> inorderTraversal(TreeNode* root) {
        ret.clear();
        inorder(root);
        return ret;
    }
};

代码六，对应力扣，二叉树的后续遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    vector<int> ret;
    void postorder(TreeNode *root){
        if(root){
        postorder(root->left);
        postorder(root->right);
        ret.push_back(root->val);
        }
    }
public:
    vector<int> postorderTraversal(TreeNode* root) {
        ret.clear();
        postorder(root);
        return ret;
    }
};

代码，对应力扣，翻转二叉树，代码见下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL){
            return NULL;
        }
        TreeNode* l = invertTree(root->left);
        TreeNode* r = invertTree(root->right);

        root->left = r;
        root->right = l;
        return root;
    }
};