二叉树-二叉搜索树（中序）

题型：

（1）验证

（2）修复（排列不正确，修复）

（3）构造（给排列求树-平衡的；种类）

（4）利用性质求第n个结点

二叉搜索树的思路：中序输出+相关操作

如果要求空间复杂度O(1)，考虑莫里斯遍历

98. 验证二叉搜索树    面试题 04.05. 合法二叉搜索树 （1）

思路：中序排列，看次序

 1 class Solution {
 2     public boolean isValidBST(TreeNode root) {
 3         // if(root==null){  // 题目空树是true
 4         //     return false;
 5         // }
 6         List<Integer> list = new ArrayList<>();
 7         inorder(root, list);
 8         for(int i=0;i<list.size()-1;i++){
 9             if(list.get(i)>=list.get(i+1)){  // 有相同元素不行，不同题目要求不同。
10                 return false;
11             }
12         }
13         return true;
14     }
15     public void inorder(TreeNode node, List<Integer> list){
16         if(node==null){
17             return;
18         }
19         inorder(node.left, list);
20         list.add(node.val);
21         inorder(node.right, list);
22         return;
23     }
24 }

99. 恢复二叉搜索树 ?? （2）

思路：中序排列，出现前结点比后结点大的情况，把这两个结点存储，最后交换这些结点的值。画一画

（1）只有一次逆序（相邻结点交换错误）：直接交换相邻的两个结点的val

（2）有两次逆序（非相邻结点交换错误）：交换第一次逆序的大值，和第二次逆序的小值。

引申：O(1)空间？

 1 class Solution {
 2     public void recoverTree(TreeNode root) {
 3         if(root==null){
 4             return;
 5         }
 6         List<TreeNode> nodeList = new ArrayList<>();
 7         inorder(root, nodeList);
 8         int left = -1;
 9         int right = -1;
10         for(int i = 0;i<nodeList.size()-1;i++){
11             if(nodeList.get(i).val > nodeList.get(i+1).val){
12                if(left==-1){
13                    left=i;
14                }else{
15                    right=i+1;
16                }
17             }
18         }
19         if(right==-1){
20             int temp = nodeList.get(left).val;
21             nodeList.get(left).val=nodeList.get(left+1).val;
22             nodeList.get(left+1).val=temp;
23         }else{
24             int temp = nodeList.get(left).val;
25             nodeList.get(left).val=nodeList.get(right).val;
26             nodeList.get(right).val=temp;
27         }
28
29     }
30     public void inorder(TreeNode node , List<TreeNode> nodeList){
31         if(node==null){
32             return;
33         }
34         inorder(node.left, nodeList);
35         nodeList.add(node);
36         inorder(node.right, nodeList);
37     }
38 }

108. 将有序数组转换为二叉搜索树 （3）

思路：二分法

 1 class Solution {
 2     public TreeNode sortedArrayToBST(int[] nums) {
 3         if(nums == null || nums.length==0){
 4             return null;
 5         }
 6         return buildTree(nums, 0, nums.length-1); // 小心数组越界
 7     }
 8     public TreeNode buildTree(int[] nums, int left, int right){
 9         if(left>right){
10             return null;
11         }
12         int mid=(left+right)/2;
13         TreeNode root = new TreeNode(nums[mid]);
14         root.left = buildTree(nums, left, mid-1);
15         root.right = buildTree(nums, mid+1, right);
16         return root;
17     }
18 }

96. 不同的二叉搜索树

思路：动态规划

 1 class Solution {
 2     public int numTrees(int n) {
 3         int[] sum = new int[n+1];
 4         sum[0]=1;
 5         for(int k=1;k<=n;k++){  // 迭代计算sum[1]=>sum[n]
 6             for(int i=1;i<=k;i++){ // 分别以1->n 作为头结点计算种类
 7                 sum[k]+=sum[i-1]*sum[k-i]; //i为根，左边i-1个结点，右边k-i个结点
 8             }
 9         }
10         return sum[n];
11     }
12 }

95. 不同的二叉搜索树 II

109. 有序链表转换二叉搜索树

501. 二叉搜索树中的众数

引申：O(1)空间？

原文地址：https://www.cnblogs.com/naonaoling/p/12364848.html