力扣二叉树题目本地测试生成测试用例Python\C++

  力扣的二叉树相关的题目，其输入都是简化的数的节点值的列表，对于我这种喜欢在本地用插件刷题的人来说，每次提交测试都很慢，所以喜欢在本地测试答案，而二叉树的题目测试案例提交的话又要经过官方的生成操作一次，所以想到在自己本地生成二叉树。于是就自己写一个，对你有帮助的话，不妨点个赞再走？
  具体的，生成的过程我们需要一个队列来帮助。

Python

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def creatTree(nodes):
    if not nodes:
        return None
    
    from queue import Queue
    que = Queue()
    root = None
    is_left = True		# 是否生成左子树
    for val in nodes:
        node = TreeNode(val) if val else None
        if que.empty():
            root = node
            que.put(node)
        
        elif is_left:
            # 获取队首结点，同时出队
            cur = que.get()
            cur.left = node
            if node:
                que.put(node)
            is_left = not is_left
        
        else:
            # 到这里的话一定会有cur变量
            cur.right = node
            if node:
                que.put(node)
            
            is_left = not is_left
    
    return root

  用Python的话直接将这个函数放到题目代码里就可以直接用了，例如：

if __name__ == '__main__':
    s = Solution()
    tree = creatTree([4,2,7,1,3,6,9])
    print(s.mirrorTree(tree))

C++

  对C++来说的话，需要建一个createTree.h和createTree.cpp，前者放函数声明，后者放具体的函数定义/实现。然后在题目文件里include这个头文件就可以用了。
createTree.h

#ifndef CLIONPROJECT_LEETCODECREATETREE_H
#define CLIONPROJECT_LEETCODECREATETREE_H
#include<vector>
#include<queue>
using namespace std;
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) {}
};

TreeNode* createTree(vector<int> nodes);

#endif //CLIONPROJECT_LEETCODECREATETREE_H

createTree.cpp

#include "LeetCodeCreateTree.h"
TreeNode* createTree(vector<int> nodes){
    if(!nodes.size()){
        return nullptr;
    }
    queue<TreeNode*> que;
    TreeNode *root, *node, *cur;
    bool is_left = true;
    for(auto val: nodes){
        node = val != 0 ? new TreeNode(val) : nullptr;
        if(que.empty()){
            root = node;
            que.push(node);
        }
        else if(is_left){
            cur = que.front();
            que.pop();
            cur->left = node;
            if(&node){
                que.push(node);
            }
            is_left = !is_left;
        }
        else{
            cur->right = node;
            if(&node){
                que.push(node);
            }
            is_left = !is_left;
        }
    }
    return root;
}

用法：
如一个二叉树的中序遍历的题：

#include<bits/stdc++.h>
#include"LeetCodeCreateTree.h"
#include<iostream>
#include<map>
#include<vector>
using namespace std;

//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if(!root) {
            return {};
        }
        vector<int> res;
        stack<TreeNode*> sk;
        TreeNode *cur = root;
        while(cur || !sk.empty()){
            if(cur){
                sk.push(cur);
                cur = cur->left;
            }
            else{
                cur = sk.top();
                sk.pop();
                res.push_back(cur->val);
                cur = cur->right;
            }
        }
        return res;
    }
};
//leetcode submit region end(Prohibit modification and deletion)

int main()
{
    vector<int> tree = {4,2,7,1,3,6,9};
    TreeNode *root = createTree(tree);
    // cout << root << endl;
    Solution s = Solution();
    vector<int> travel = s.inorderTraversal(root);
    for(auto a: travel){
        cout << a << " " << endl;
    }
    return 0;
}