02. 剑指offer刷题-二叉树篇（第一部分）

 

class Solution {
public:
    int TreeDepth(TreeNode* pRoot) {

		if(pRoot == nullptr) return 0;

		int left = TreeDepth(pRoot->left);
		int right = TreeDepth(pRoot->right);

		return max(left, right) + 1;
    }
};

class Solution {
public:

    int KthNode(TreeNode* proot, int k) {
        
        int res = traversal(proot, k);
        return res;
    }

    int traversal(TreeNode* proot, int& k){

        if(proot == nullptr) return -1;
        
        int left = traversal(proot->left, k);
        k--; if(k == 0) return proot->val;
        int right = traversal(proot->right, k);

        if(left == -1 && right == -1) return -1;
        else if(left != -1) return left;
        else return right;
    }
};

 

 

class Solution {
public:

    TreeNode* reConstructBinaryTree(vector<int>& preOrder, vector<int>& vinOrder) {

        if(preOrder.size() < 1) return nullptr;

        TreeNode* root = new TreeNode(preOrder[0]);

        int cut_index = 0;
        for(int i = 0; i < vinOrder.size(); i++){
            if(vinOrder[i] == preOrder[0]) {cut_index = i; break;}
        }

        vector<int> pre_left(preOrder.begin() + 1, preOrder.begin() + cut_index + 1);
        vector<int> pre_right(preOrder.begin() + cut_index + 1, preOrder.end());

        vector<int> vin_left(vinOrder.begin(), vinOrder.begin() + cut_index);
        vector<int> vin_right(vinOrder.begin() + cut_index + 1, vinOrder.end());

        root->left = reConstructBinaryTree(pre_left, vin_left);
        root->right = reConstructBinaryTree(pre_right,vin_right);

        return root;
    }
};

class Solution {
public:
    // 这个函数用「遍历」的思维模式理解，遍历二叉树 A 的所有节点
    bool isSubStructure(TreeNode* A, TreeNode* B) {
                if (A == nullptr || B == nullptr) {
            return false;
        }
        // 对于树 A 中的一个节点：
        // 1. 如果 A.val == B.val，则 A 可以作为根节点尝试去匹配树 B
        if (A->val == B->val && compareTree(A, B)) {
            return true;
        }
        // 2. 如果 A.val != B.val，就不要去匹配树 B 了
        return isSubStructure(A->left, B) || isSubStructure(A->right, B);
    }

    // 这个函数用「分解问题」的思路理解
    // 定义：输入两个根节点，返回从 rootA 开始是否可以完全匹配 rootB 树上的所有节点
    bool compareTree(TreeNode* rootA, TreeNode* rootB) {
        // base case
        if (rootB == nullptr) {
            return true;
        }
        if (rootB != nullptr && rootA == nullptr) {
            return false;
        }
        if (rootA->val != rootB->val) {
            return false;
        }

        // rootA 的值和 rootB 的值匹配完成，去匹配子树的节点
        return compareTree(rootA->left, rootB->left) && compareTree(rootA->right, rootB->right);
    }
};

class Solution {
public:

    TreeNode* Mirror(TreeNode* pRoot) {

        if(pRoot == nullptr) return nullptr;

        swap(pRoot->left, pRoot->right);
        Mirror(pRoot->left);
        Mirror(pRoot->right);
        
        return pRoot;
    }
};

class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {

		vector<int> res;
		if(root == nullptr) return res;
		
		queue<TreeNode*> que;
		que.push(root);

		while(!que.empty()){
			int que_size = que.size();

			for(int i = 0; i < que_size; i++){
				TreeNode* temp = que.front();
				que.pop(); res.push_back(temp->val);
				if(temp->left != nullptr) que.push(temp->left);
				if(temp->right != nullptr) que.push(temp->right);
			}
		}
		return res;
    }
};

class Solution {
public:
    bool verifyTreeOrder(vector<int>& postorder) {
        return check(postorder, 0, postorder.size() - 1);
    }

     // 定义：检查 postorder[i..j] 是否是一个合法的 BST
    bool check(vector<int>& postorder, int i, int j) {
        if (i >= j) {
            return true;
        }
        // 根节点的值是后序遍历结果的最后一个元素
        int root = postorder[j];

        // postorder[i..left) 是左子树，应该都小于 root
        int left = i;
        while (left < j && postorder[left] < root) {
            left++;
        }

        // postorder[left..j) 是右子树，应该都大于 root
        int right = left;
        while (right < j && postorder[right] > root) {
            right++;
        }
        if (right != j) {
            return false;
        }
        // 递归检查左子树 [i..left) 和右子树 [left..j) 也符合 BST 的性质
        return check(postorder, i, left - 1) && check(postorder, left, j - 1);
    }
};