剑指offer--二叉树

第3题：二叉搜索树的第k个节点

• 描述
  给定一棵结点数为n的二叉搜索树，请找出其中的第k小的TreeNode结点值。

1. 返回第k小的节点值即可
2. 不能查找的情况，如二叉树为空，则返回-1，或者k大于n等等，也返回-1
3. 保证n个节点的值不一样

• 思路
  • 递归中序遍历
    二叉搜索树：左子树的元素都小于根节点，右子树的元素都大于根节点。因此它的中序遍历（左中右）序列正好是由小到大的次序。
    • 具体做法
      1. 设置全局变量count记录遍历了多少个节点，res记录第k个节点。
      2. 另写一函数进行递归中序遍历，当节点为空或者超过k时，结束递归，返回。
      3. 优先访问左子树，再访问根节点，访问时统计数字，等于k则找到。
      4. 最后访问右子树

  class Solution {
  public:
  	//记录返回的节点
  	TreeNode* res = NULL;
  	//记录中序遍历了多少个
  	int count = 0;
  	//当遍历到节点为空或者超过k时，返回
  	void midOrder(TreeNode* root, int k){
  		if(root == NULL || count > k) 
  			return;
  		midOrder(root->left, k);
  		count++;
  		//只记录第k个
  		if(count == k)
  			res = root;
  		midOrder(root->right, k);
  	}
  	int KthNode(TreeNode* proot, int k) {
  		midOrder(proot, k);
  		if(res)
  			return res->val;
  		//二叉树为空，或是找不到
  		else 
  			return -1;
  	}
  };
  

  • 栈
    • 具体做法
      1. 用栈记录当前节点，不断往左深入，直到左边子树为空。
      2. 再弹出栈顶（即为当前子树的父节点），访问该节点，同时计数
      3. 然后再访问其右子树，其中没棵子树都遵循左中右的次序
      4. 直到第k个节点返回，如果遍历结束也没找到，则返回-1.
    • 代码

    class Solution{
    	public:
    		int kthNode(TreeNode* proot,int k){
    			if(proot==nullptr) return -1;
    			int count = 0;
    			TreeNode* p = nullptr;
    			stack<TreeNode*> s;
    			while(!s.empty()||proot!=nullptr){
    				while(proot!=nullptr){
    					s.push(proot);
    					proot = proot->left;
    				}
    				p = s.top();
    				s.pop();
    				count++;
    				if(count==k) return p->val;
    				proot = p->right;
    			}
    			return -1;
    		}
    }
    

第4题：重建二叉树

描述

给定节点数为 n 的二叉树的前序遍历和中序遍历结果，请重建出该二叉树并返回它的头结点。

思路

递归

step 1：先根据前序遍历第一个点建立根节点。

step 2：然后遍历中序遍历找到根节点在数组中的位置。

step 3：再按照子树的节点数将两个遍历的序列分割成子数组，将子数组送入函数建立子树。

step 4：直到子树的序列长度为0，结束递归。

class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        int n = pre.size();
        int m = vin.size();
        //每个遍历都不能为0
        if(n == 0 || m == 0) 
            return NULL;
        //构建根节点
        TreeNode *root = new TreeNode(pre[0]); 
        for(int i = 0; i < vin.size(); i++){
            //找到中序遍历中的前序第一个元素
            if(pre[0] == vin[i]){ 
                //左子树的前序遍历
                vector<int> leftpre(pre.begin() + 1, pre.begin() + i + 1);  
                //左子树的中序遍历
                vector<int> leftvin(vin.begin(), vin.begin() + i); 
                //构建左子树
                root->left = reConstructBinaryTree(leftpre, leftvin); 
                //右子树的前序遍历
                vector<int> rightpre(pre.begin() + i + 1, pre.end()); 
                //右子树的中序遍历
                vector<int> rightvin(vin.begin() + i + 1, vin.end()); 
                //构建右子树
                root->right = reConstructBinaryTree(rightpre, rightvin); 
                break;
            }
        }
        return root;
    }
};

栈模拟递归

step 1：首先前序遍历第一个数字依然是根节点，并建立栈辅助遍历。

step 2：然后我们就开始判断，在前序遍历中相邻的两个数字必定是只有两种情况：要么前序后一个是前一个的左节点；要么前序后一个是前一个的右节点或者其祖先的右节点。

step 3：我们可以同时顺序遍历pre和vin两个序列，判断是否是左节点，如果是左节点则不断向左深入，用栈记录祖先，如果不是需要弹出栈回到相应的祖先，然后进入右子树，整个过程类似非递归前序遍历。

class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        int n = pre.size();
        int m = vin.size();
        //每个遍历都不能为0
        if(n == 0 || m == 0) 
            return NULL;
        stack<TreeNode*> s;
        //首先建立前序第一个即根节点
        TreeNode *root = new TreeNode(pre[0]); 
        TreeNode *cur = root;
        for(int i = 1, j = 0; i < n; i++){
            //要么旁边这个是它的左节点
            if(cur->val != vin[j]){ 
                cur->left = new TreeNode(pre[i]);
                s.push(cur);
                //要么旁边这个是它的右节点，或者祖先的右节点
                cur = cur->left; 
            }else{
                j++;
                //弹出到符合的祖先
                while(!s.empty() && s.top()->val == vin[j]){ 
                    cur = s.top();
                    s.pop();
                    j++;
                }
                //添加右节点
                cur->right = new TreeNode(pre[i]); 
                cur = cur->right;
            }
        }
        return root;
    }
};