LeetCode 95. Unique Binary Search Trees II

• 描述
  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

• 思路
  涉及到节点的很多算法题都可以考虑使用递归的方法进行求解，这里是二叉树，所以可以这样考虑，假如给定的n=5，那么，可以分解成这么几种情况：1、左边有0个节点，右边有4个节点；2、左边有1个节点，右边有3个节点；3、左边有2个节点，右边有2个节点；4、左边有3个节点，右边有1个节点；5、左边有4个节点，右边有0个节点.，这样五种情况。问题就变成求这五种情况了。而这五种情况又可以进一步的细分，直到变成左边有0个节点，右边有0个节点的情况。在左右两边都为0个节点的情况下面，只需要返回一个新节点即可下面给出代码。
• 代码（c#）

public IList<TreeNode> GenerateTrees(int n)
        {
            if (n == 0) return new List<TreeNode>();
            IList<TreeNode> list = AddNum(0, n);//左边0个节点，右边n个节点
            for (int i = 0; i < list.Count; i++)
            {
                int index = 1;
                SetValue(list[i].right, ref index);//中序遍历为节点赋值
                list[i] = list[i].right;//将头结点置为右边的第一个节点
            }
            return list;
        }
        public void SetValue(TreeNode treeNode, ref int index)
        {
            if (treeNode != null)
            {
                SetValue(treeNode.left, ref index);
                treeNode.val = index++;
                SetValue(treeNode.right, ref index);
            }
        }
        public IList<TreeNode> AddNum(int leftNum, int rightNum)
        {
            List<TreeNode> result = new List<TreeNode>();
            List<TreeNode> left = new List<TreeNode>();
            List<TreeNode> right = new List<TreeNode>();
            if (leftNum == 0 && rightNum == 0)
            {
                result.Add(new TreeNode(0));
                return result;
            }//递归结束，左右两边的节点都为0
            if (leftNum > 0)
            {

                for (int i = 0; i < leftNum; i++)
                {
                    left.AddRange(AddNum(i, leftNum - i - 1));//将左边所有的情况添加到左队列中
                }
            }
            if (rightNum > 0)
            {
                for (int i = 0; i < rightNum; i++)
                {
                    right.AddRange(AddNum(i, rightNum - i - 1));//将右边所有的情况添加到右队列中
                }
            }
            if (right.Count > 0 && left.Count == 0)
            {//右边情况大于0，左边的节点为0，这种情况下只需要将头结点的右节点赋值即可
                foreach (var item in right)
                {
                    TreeNode head = new TreeNode(0);
                    head.right = item;
                    result.Add(head);
                }
            }
            else if (left.Count > 0 && right.Count == 0)
            {//跟上面的情况相反，这里只需要将头结点的左节点赋值即可
                foreach (var item in left)
                {
                    TreeNode head = new TreeNode(0);
                    head.left = item;
                    result.Add(head);
                }
            }
            else
            {//左右节点都有值，此时共要生成（左节点的情况个数*右节点的情况个数）个头节点
                for (int i = 0; i < left.Count; i++)
                {
                    for (int j = 0; j < right.Count; j++)
                    {
                        TreeNode head = new TreeNode(0);
                        head.left = left[i];
                        head.right = right[j];
                        result.Add(head);
                    }
                }
            }
            return result;
        }

• 代码优化
  上面的代码能在leetcode上面ac，但是显然效率比较低。这个时候可以分析效率较低的原因，主要是因为递归，因为递归的执行效率是比较低的，尤其是当n比较大的时候。这个时候可以考虑将递归算法转化成非递归的算法。递归的算法是将大n逐步的化小，直至能够求解。假如从反向考虑也是可以的，首先我们求出n=1的情况，然后在求解n=2的情况，最后求解出给定的n。需要注意的是，非递归的方法需要用一个特殊的内存保存已求解的值。具体代码见下。
• 非递归的方法代码（c#）

 public IList<TreeNode> GenerateTrees(int n)
        {
            if (n == 0) return new List<TreeNode>();
            List<TreeNode>[,] arr =new  List <TreeNode >[n + 1, n + 1];//用于保存已确定的节点结构
            arr[0, 0] = new List<TreeNode>();
            arr[1, 0] = new List<TreeNode>();
            arr[1, 0].Add(new TreeNode(0));
            arr[0, 1] = arr[1, 0];
            arr[0, 0].Add(new TreeNode(0));
            for (int i = 2; i <= n; i++)
            {
                arr[0, i] = new List<TreeNode>();
                for (int j = 0; j < i; j++)
                {
                    List<TreeNode> list = new List<TreeNode>();
                    if (j != 0 && (i - j - 1) != 0)
                    {   //这种情况对应递归方法里面的左右节点都有值
                        var left = CopyList( arr[j, 0]);
                        var right = CopyList(arr[0, i - j - 1]);
                        for (int l = 0; l < left.Count; l++)
                        {

                            for (int r = 0; r < right.Count; r++)
                            {
                                var head = new TreeNode(0);
                                head.left = left[l];
                                head.right = right[r];
                                list.Add(head);
                            }
                        }
                    }
                    else
                    {
                        var result = CopyList(arr[j, i - j - 1]);//复制一个节点集合的结构
                        for (int l = 0; l < result.Count; l++)
                        {
                            var head = new TreeNode(0);
                            if (j == 0)
                            {
                                head.left = result[l];//只有左节点有值                            
                            }
                            else
                            {
                                head.right = result[l];//只有右节点有值
                            }
                            list.Add(head);
                        }
                    }
                    arr[0, i].AddRange(list);
                }
                arr[i, 0] = arr[0, i];//左边有i个节点跟右边有i个节点的情况是一样的
            }
            var last = arr[0, n];
            for (int i = 0; i < last.Count; i++)
            {
                int index = 1;
                SetValue(last[i], ref index);//使用中序遍历为每一个节点赋值
            }
            return last;
        }
        public List<TreeNode> CopyList(List<TreeNode> list)
        {
            List<TreeNode> result = new List<TreeNode>();
            for (int i = 0; i < list.Count; i++)
            {
                TreeNode node = new TreeNode(0);
                CopyNode(list[i], node);//复制每集合中每一个节点的结构
                result.Add(node);
            }
            return result;
        }
        public void CopyNode(TreeNode node,TreeNode result)
        {
            if (node.right != null)
            {
                result.right = new TreeNode(0);
                CopyNode(node.right, result.right);
            }
            if (node.left != null)
            {
                result.left = new TreeNode(0);
                CopyNode(node.left, result.left);
            }
        }
 public void SetValue(TreeNode treeNode, ref int index)
        {
            if (treeNode != null)
            {
                SetValue(treeNode.left, ref index);
                treeNode.val = index++;
                SetValue(treeNode.right, ref index);
            }
        }

• 相关链接
  LeetCode原题地址:https://leetcode.com/problems/unique-binary-search-trees-ii/description/