力扣二叉树本地仿真框架

力扣刷题，对于链表类和二叉树类，本地调试比较麻烦。需要先把力扣输入数据转换成本地格式，再建立本地框架，而且调试结束，树的结构及数据不能直接看到。比对结果比较麻烦。

幸得网上看到一篇文章：《Leetcode刷题本地debug框架搭建》，读了以后很受启发。我将其略加改造，建立了全仿真力扣输入输出模式，可以按力扣网页IDE的方式输出结果。方便大家。

以下代码以leetcode 450题为例：删除二叉树的节点

#include <bits/stdc++.h>
using namespace std;
#define null INT_MAX //把力扣给定的null节点定义为int的最大值，用于识别空结点
//二叉树的结构体定义
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 *CreatTree(vector<int> &layerorder);       //根据给定的层序序列建树的函数
int hightOfTree(TreeNode *root);                 	//层序遍历获取树高
vector<int> LayerOfTree(TreeNode *root, int h);           //层序遍历为了输出
void Print(vector<int> arr);       					//用于打印数组的函数
 在这里放入Solution类 /
///类开始
class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(root==nullptr || root->val==key && !root->left && !root->right) return nullptr;
        if(root->val==key)
        {
            TreeNode* newroot=new TreeNode(INT_MAX);
            newroot->left=root;
            findnode(newroot,key);
            return newroot->left;
        }
        else
        {
            findnode(root,key);
            return root;     
        }         
    } 
    void findnode(TreeNode* &root,int key)
    {
        if(key<root->val)
        {
            if(!root->left) return;
            if(key==root->left->val) deNode(root,"left");
            else findnode(root->left,key);
        } 
        else 
        {
            if(!root->right) return;
            if(key==root->right->val) deNode(root,"right");
            else findnode(root->right,key); 
        }       
    }
    void deNode(TreeNode* &root,string son)
    {
        if(son=="right")
        {
            TreeNode* node=root->right;
            if(!node->left && !node->right)
            {
                root->right=nullptr;
                delete node;
            }
            else if(node->left && !node->right)
            {
                root->right=node->left;
                delete node;
                return;
            }
            else if(node->right && !node->left)
            {
                root->right=node->right;
                delete node;
                return;
            }
            else
            {
                TreeNode* p=node->right;
                while(p->left)
                    p=p->left;
                int t=p->val;
                findnode(node,t);
                node->val=t;
            }
        }
        else if(son=="left")
        {
            TreeNode* node=root->left;
            if(!node->left && !node->right)
            {
                root->left=nullptr;
                delete node;
            }
            else if(node->left&&!node->right)
            {
                root->left=node->left;
                delete node;
                return;
            }
            else if(node->right && !node->left)
            {
                root->left=node->right;
                delete node;
                return;
            }
            else
            {
                TreeNode* p=node->left;
                while(p->right)
                    p=p->right;
                int t=p->val;
                findnode(node,t);
                node->val=t;
            }
        }     
    }
}; 
///类结束

int main()
{
	//---树的层序序列，复制力扣输入数据---//
	vector<int> layerorder = {5,3,6,2,4,null,7};
	int key = 3;
	//---数据输入结束---//

	//建树，返回根节点
	TreeNode *root = CreatTree(layerorder);
	
	Solution mysolution;

	//---此处调用你的方法---//
	root = mysolution.deleteNode(root, key);
	//---调用方法结束---//
	
	//仿真力扣方式输出
	int h = hightOfTree(root);
	vector<int> out = LayerOfTree(root, h);
	Print(out);//输出：[5,4,6,2,null,null,7
	return 0;
}

TreeNode *CreatTree(vector<int> &layerorder)    //根据层序序列建树
{
	int n = layerorder.size();
	if (n == 0) return nullptr;                 //计算序列元素个数，如果空树返回空指针
	queue<TreeNode*> q;
	TreeNode *root = new TreeNode(layerorder[0]); //创建根结点并入队
	q.push(root);
	for (int i = 0; i <= (n - 1) / 2; i++)      //只需处理第一个结点到最后一个非叶子结点
	{
		if (layerorder[i] == null) continue;    //如果是空结点则跳过
		TreeNode* now = q.front();              //从队列中取出当前结点
		q.pop();
		int left = 2 * i + 1, right = 2 * (i + 1); //计算当前结点的左右孩子的位置
		if (left < n && layerorder[left] != null) //如果左孩子存在且不为空时创建左孩子结点并入队
		{
			now->left = new TreeNode(layerorder[left]);
			q.push(now->left);
		}
		if (right < n && layerorder[right] != null) //如果右孩子存在且不为空时创建右孩子结点并入队
		{
			now->right = new TreeNode(layerorder[right]);
			q.push(now->right);
		}
	}
	return root;                                //返回创建好的树
}
int hightOfTree(TreeNode *root)                 //层序遍历获取树高
{
	if (root == nullptr) return 0;
	int hight = 0;
	queue<TreeNode*> q;
	q.push(root);
	while (!q.empty())
	{
		hight++;
		int size = q.size();
		for (int i = 0; i < size; i++)
		{
			TreeNode* now = q.front();
			q.pop();
			if (now->left) q.push(now->left);
			if (now->right) q.push(now->right);
		}
	}
	return hight;
}

vector<int> LayerOfTree(TreeNode *root, int h)   //层序遍历为了输出
{
	vector<int> layer;
	if (root == nullptr) return layer;
	queue<TreeNode*> q;
	q.push(root);
	while (h--)
	{
		int size = q.size();
		for (int i = 0; i < size; i++)
		{
			TreeNode* now = q.front();
			if (now == nullptr) layer.push_back(null);
			else layer.push_back(now->val);
			q.pop();
			if (!now) q.push(nullptr);
			else if (now->left) q.push(now->left);
			else q.push(nullptr);
			if (!now) q.push(nullptr);
			else if (now->right) q.push(now->right);
			else q.push(nullptr);
		}
	}
	return layer;
}
void Print(vector<int> arr)       //用于打印结果序列的函数
{
	int n = arr.size();
	cout << "[";
	for (int i = 0; i < n; i++)
	{
		if (arr[i] == null) cout << "null"<<",";
		else cout << arr[i] << ",";
	}
	cout << "]";
}

原文：http://www.hzhcontrols.com/new-1657986.html
欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利