剑指offer-树3m-5

---

JZ54 (m)二叉搜索树的第k个节点

• 中序遍历二叉树；栈的使用
  不断向左走，如果走不动就向右走一个，重复此过程

  class Solution {
  public:
      int KthNode(TreeNode* proot, int k) {
          // write code here
          if(!proot) return -1;
          
          stack<TreeNode*> s;
          TreeNode *node=proot;
          int i=0;
          while(!s.empty()||node){
              while(node){
                  s.push(node);
                  node=node->left;
              }
              node=s.top();
              s.pop();
              
              ++i;
              if(i==k) 
                  return node->val;
  
              node = node->right;
          }
          return -1;
      }
  };
  

JZ7 (m)重建二叉树

• 递归，由前序遍历得到根节点，在中序遍历中找到根节点的位置，此位置左边为左子树，右边为右子树，划分清楚之后继续向下递归。

  class Solution {
  public:
      TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
          if(pre.empty()) return nullptr;
          int pivot = pre[0];
          int i=0;
          for(;i<vin.size();++i){
              if(vin[i]==pivot) break;
          }
          TreeNode *root=new TreeNode(pivot);
          
          vector<int> left_pre,right_pre,left_vin,right_vin;
          for(int j=0;j<i;++j){
              left_pre.push_back(pre[j+1]);
              left_vin.push_back(vin[j]);
          }
          for(int j=i+1;j<pre.size();++j){
              right_pre.push_back(pre[j]);
              right_vin.push_back(vin[j]);
          }
          root->left=reConstructBinaryTree(left_pre, left_vin);
          root->right=reConstructBinaryTree(right_pre, right_vin);
          return root;
      }
  };
  

JZ26 (m)树的子结构

• 递归

  class Solution {
  public:
      bool IsSame(TreeNode *pRoot1, TreeNode *pRoot2){
          bool left =true,right=true;
          if(!pRoot1||pRoot1->val!=pRoot2->val) return false;
          if(pRoot2->left) left=IsSame(pRoot1->left, pRoot2->left);
          if(pRoot2->right) right=IsSame(pRoot1->right, pRoot2->right);
          return left&&right;
      }
      bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2) {
          if(!pRoot1||!pRoot2) return false;
          if(IsSame(pRoot1, pRoot2)) return true;
          if(HasSubtree(pRoot1->left, pRoot2) || HasSubtree(pRoot1->right, pRoot2)) return true;
          return false;
      }
  };