leecode 解题总结：95. Unique Binary Search Trees II

#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
/*
问题:
Given an integer n, generate all structurally unique BST's (binary search trees) that store values 1...n.

For example,
Given n = 3, your program should return all 5 unique BST's shown below.

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

分析:这道题目实际上就是构建二叉查找树。二叉查找树由于不能调整位置，因此输入的
数据顺序会对树的形状产生影响。可以每次尝试不同的输入顺序：
比如1，2,3或者1,3,2；或者2,1,3；或者3,1,2或者3,2,1
但是即使用不同的顺序，可能会产生重复，比如:2,1,3和2,3,1产生的树的形状是一样的。
根本原因在于选用的根节点恰好是中间的数据。
简单的方式就是：每次产生一棵树，就和之前产生的所有树比较，看是否重复，如果重复
就过滤。
判断两棵树是否相同，可以递归得判定。
先判定两棵树当前结点值是否相同，如果不相同，直接返回两棵树不同；
否则，递归判定当前结点的左右子树是否相同即可

对于不同的输入：这个需要通过排列生成

输入:
3
输出:
1 3 2,3 2 1,3 1 2,2 1 3,1 2 3

关键:
1 采用排列+构建二叉查找树+去重做
2 leecode解法:https://leetcode.com/problems/unique-binary-search-trees-ii/?tab=Solutions
 由于二叉查找树是中序，因此，可以选定[1...n]中任意数i为根节点，
 那么左子树为[1...i-1]，右子树为[i+1...len]
 如果发现左边=右边，说明当前要生成的就是一个结点，就把结点当做根节点压入【参见n为1的情况】
 如果左边>右边，不可能，返回空插入

 本质是不断从给定的序列中选定一个成为根节点，令左半段成为左子树，令右半段成为右子树。
 牛逼，以后看到树的问题多从递归入手

 	//注意每颗子树中也会产生不同的根节点，因此返回的左子树也是一个数组，右子树也是一个数组，然后做笛卡尔积
	vector<TreeNode*> buildTree(int start , int end )
*/

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

class Solution {
public:
	//注意每颗子树中也会产生不同的根节点，因此返回的左子树也是一个数组，右子树也是一个数组，然后做笛卡尔积
	vector<TreeNode*> buildTree(int start , int end )
	//TreeNode* buildTree(int start , int end,  vector<TreeNode*>& result)
	{
		vector<TreeNode*> result;
		 //递归出口，返回的NULL，实际上可能是
		if(start > end)
		{
			result.push_back(NULL);
			return result;
		}
		//只提供一个结点，则直接是根节点，后续会遍历到这里
		if(start == end)
		{
			TreeNode* node = new TreeNode(start);
			result.push_back(node);
			return result;
		}
		vector<TreeNode*> lefts;
		vector<TreeNode*> rights;
		int leftSize;
		int rightSize;
		for(int i = start ; i <= end ; i++)
		{
			lefts = buildTree(start  , i - 1);
			rights = buildTree(i + 1 , end);
			leftSize = lefts.size();
			rightSize = rights.size();
			for(int j = 0 ; j < leftSize; j++)
			{
				for(int k = 0 ; k < rightSize ; k++)
				{
					TreeNode* root = new TreeNode(i);
					root->left = lefts.at(j);
					root->right = rights.at(k);
					result.push_back(root);
				}
			}
		}
		return result;
	}

    vector<TreeNode*> generateTrees(int n) {
		vector<TreeNode*> nodes;
		if(n <= 0)
		{
			return nodes;
		}
		nodes = buildTree(1 , n);
		return nodes;
	}
};

class Solution2 {
public:
	void permutate(int n,int pos , vector<int>& result, vector< vector<int> >& results)
	{
		if(pos == n)
		{
			results.push_back(result);
			return;
		}
		bool isOk;
		for(int i = 1 ; i <= n ; i++)
		{
			isOk = true;
			for(int j = 0 ; j < pos ; j++)
			{
				if(i == result.at(j))
				{
					isOk = false;
					break;
				}
			}
			if(isOk)
			{
				result.push_back(i);
				permutate(n , pos + 1 , result , results);
				result.pop_back();
			}
		}
	}

	TreeNode* insertNode(TreeNode* root , int value)
	{
		if(!root)
		{
			return NULL;
		}
		//如果给定值> 根节点值，如果右孩子为空，作为右孩子，否则以右孩子作为根节点，递归
		if(value >= root->val)
		{
			if(NULL == root->right)
			{
				TreeNode* node = new TreeNode(value);
				root->right = node;
			}
			else
			{
				insertNode(root->right , value);	
			}
		}
		else
		{
			if(NULL == root->left)
			{
				TreeNode* node = new TreeNode(value);
				root->left = node;
			}
			else
			{
				insertNode(root->left , value);
			}
		}
		return root;
	}

	bool isSameTree(TreeNode* root1 , TreeNode* root2)
	{
		//如果两个当前结点都为空，则相同
		if(NULL == root1 && NULL ==  root2)
		{
			return true;
		}
		else if(NULL == root1)
		{
			return false;
		}
		else if(NULL == root2)
		{
			return false;
		}
		if(root1->val != root2->val)
		{
			return false;
		}
		return isSameTree(root1->left , root2->left) && isSameTree(root1->right ,root2->right);
	}

	//判断当前二叉查找树是否和集合中的二叉查找树重复
	bool isRepeated(vector<TreeNode*>& nodes , TreeNode* root)
	{
		if(nodes.empty())
		{
			return false;
		}
		int size = nodes.size();
		for(int i = 0 ; i < size ; i++)
		{
			if(isSameTree(nodes.at(i) , root))
			{
				return true;
			}
		}
		return false;
	}

    vector<TreeNode*> generateTrees2(int n) {
		vector<TreeNode*> nodes;
		if(n <= 0)
		{
			return nodes;
		}
        vector< vector<int> > results;
		vector<int> result;
		permutate(n , 0 , result , results);
		int size = results.size();
		//尝试不同的数据输入，来构建二叉树
		int len;
		for(int i = 0 ; i < size ; i++)
		{
			len = results.at(i).size();
			TreeNode* root = NULL;
			for(int j = 0 ; j < len ; j++ )
			{
				if(j)
				{
					root = insertNode(root , results.at(i).at(j)  );
				}
				//输入根节点
				else
				{
					root = new TreeNode( results.at(i).at(j) );
				}
			}

			//构建完了二叉查找树，下面判断是否重复
			if(nodes.empty())
			{
				nodes.push_back(root);
			}
			//如果
			else
			{
				//如果不重复
				if(!isRepeated(nodes , root))
				{
					nodes.push_back(root);
				}
			}
			
		}
		return nodes;
    }
};

//根左右
void preOrderVisit(TreeNode* root , vector<int>& result)
{
	if(NULL == root)
	{
		return;
	}
	if(root)
	{
		result.push_back(root->val);
	}
	preOrderVisit(root->left, result);
	preOrderVisit(root->right , result);
}

//打印每颗二叉查找树，用前序方式
void print(vector<TreeNode*>& result)
{
	if(result.empty())
	{
		cout << "no result" << endl;
		return;
	}
	int size = result.size();
	int len;
	for(int i = 0 ; i < size ; i++)
	{
		vector<int> datas;
		preOrderVisit(result.at(i) , datas);
		len = datas.size();
		for(int j = 0 ; j < len ; j++)
		{
			cout << datas.at(j) << " ";
		}
		cout << ",";
	}
	cout << endl;
}

//如果删除一棵树，只能先递归删除其左右子树，如果遇到一个结点没有左右孩子，就删除
void deleteTree(TreeNode* node)
{
	//如果当前结点为空，无需删除，直接返回
	if(!node)
	{
		return;
	}
	else if(NULL == node->left && NULL == node->right)
	{
		delete node;
		node = NULL;
	}
	if(node)
	{
		deleteTree(node->left);
		deleteTree(node->right);
	}
}

void deleteTrees(vector<TreeNode*>& nodes)
{
	if(nodes.empty())
	{
		return;
	}
	int size = nodes.size();
	for(int i = 0 ; i < size ; i++)
	{
		deleteTree(nodes.at(i));
	}
}

void process()
{
	 vector<int> nums;
	 int value;
	 int num;
	 Solution solution;
	 vector<TreeNode*> result;
	 while(cin >> num )
	 {
		 result = solution.generateTrees(num);
		 print(result);
		 deleteTrees(result);
	 }
}

int main(int argc , char* argv[])
{
	process();
	getchar();
	return 0;
}