tree：唯一二叉搜索树2

Leetcode, UniqueBinarySearchTrees2

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

struct TreeNode
{
	int _val;
	TreeNode *_left;
	TreeNode *_right;
	TreeNode(int x) : _val(x), _left(nullptr), _right(nullptr) { }
};

//栈 时间复杂度O（n）,空间复杂度O（n）
vector<int> inorder(TreeNode *root)
{
	vector<int> result;
	stack<const TreeNode*> s;
	const TreeNode *p = root;

	while (!s.empty() || p != nullptr)
	{
		if (p != nullptr)
		{
			s.push(p);
			p = p->_left;
		}
		else
		{
			p = s.top();
			s.pop();
			result.push_back(p->_val);

			p = p->_right;
		}
	}

	return result;
}


//栈 时间复杂度O（n）,空间复杂度O（n）
vector<int> preorder(TreeNode *root)
{
	vector<int> result;
	stack<const TreeNode*> s;
	const TreeNode *p = root;

	if (p != nullptr) s.push(p);

	while (!s.empty())
	{
		p = s.top();
		s.pop();
		result.push_back(p->_val);

		if (p->_right != nullptr) s.push(p->_right);
		if (p->_left != nullptr) s.push(p->_left);
	}

	return result;
}

vector<TreeNode *> generate(int start, int end)
{
	vector<TreeNode *> subTree;
	if (start > end)
	{
		subTree.push_back(nullptr);
		return subTree;
	}
	for (int k = start; k <= end; ++k)
	{
		auto leftSub = generate(start, k - 1);
		auto rightSub = generate(k + 1, end);
		for (auto i : leftSub)
		{
			for (auto j : rightSub)
			{
				TreeNode *root = new TreeNode(k);
				root->_left = i;
				root->_right = j;
				subTree.push_back(root);
			}
		}
	}
	return subTree;
}

vector<TreeNode *> solution(int n)
{
	if (n == 0) return generate(1, 0);
	return generate(1, n);
}

int main()
{
	auto vec = solution(3);
	//中序遍历
	for (auto node : vec )
	{
		auto res = inorder(node);
		for (auto val : res)
		{
			cout << val << "\t";
		}
		cout << endl;
	}
	//中序遍历输出结果
	//1 2 3
	//1 2 3
	//1 2 3
	//1 2 3
	//1 2 3

	//前序遍历
	for (auto node : vec)
	{
		auto res = preorder(node);
		for (auto val : res)
		{
			cout << val << "\t";
		}
		cout << endl;
	}
	//前序遍历输出结果
	//1 2 3
	//1 3 2
	//2 1 3
	//3 1 2
	//3 2 1

	return 0;
}