Today is still the application of search algorithm, but today there are more depth-first search algorithms, the data structure is still a tree, involves more knowledge of recursion, so the code volume is less.

Swordfinger Offer 26.Substructure of Trees

Enter two binary trees A and B to determine if B is a substructure of A. (A convention empty tree is not a substructure of any tree)

B is the substructure of A, that is, A has the same structure and node values as B.

Example 1:

Input: A = [1,2,3], B = [3,1]
Output: false

Example 2:

Input: A = [3,4,5,1,2], B = [4,1]
Output: true

Restrictions:

0 <= Number of nodes <= 10000

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSim(TreeNode* A, TreeNode* B){
        if(B == nullptr)return true;
        if(A == nullptr)return false;
        if(A->val != B->val)return false;
        return isSim(A->left, B->left) && isSim(A->right, B->right);
    }
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if(B == nullptr || A == nullptr)return false;
        if(A->val == B->val){
            if(isSim(A, B) == true)return true;
        }
        return isSubStructure(A->left, B) || isSubStructure(A->right, B);
    }
};

Algorithmic ideas:

This question mainly refers to tree traversal. First, traverse the tree to find the nodes that may have the same structure as B (t->val == B->val)Then another traversal function is enabled at this point to determine if B is isomorphic, whether it is isomorphic is recursive, whether the root node is the same, and whether the left and right subtrees are isomorphic. Knowing that B is empty or A is empty or the Vals of the child nodes are no longer the same, because it only determines whether B is a substructure of A, so when B traverses to nullptr it has been shown that A can match all the nodes before B.You can return true.

Swordfinger Offer 27.Mirror of Binary Tree

Please complete a function, enter a binary tree, which outputs its mirror.

Example 1:

Input: root = [4,2,7,1,3,6,9]
Output:[4,7,2,9,6,3,1]

Restrictions:

0 <= Number of nodes <= 1000

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if(root == nullptr)return nullptr;
        TreeNode* tmp = root->left;
        root->left = mirrorTree(root->right);
        root->right = mirrorTree(tmp);
        return root;
    }
};

Algorithmic ideas:

This question is still recursive, mirroring the left and right subtrees in turn, and then swapping the left and right subtrees, you can complete the mirroring of the whole tree.

Sword Finger Offer 28.Symmetric Binary Tree

Implement a function to determine if a binary tree is symmetrical. If a binary tree is the same as its mirror, then it is symmetrical.

Example 1:

Input: root = [1,2,2,3,4,4,3]
Output: true

Example 2:

Input: root = [1,2,2,null,3,null,3]
Output: false

Restrictions:

0 <= Number of nodes <= 1000

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool dfs(TreeNode* a, TreeNode *b){
        if(a == nullptr && b == nullptr)return true;
        if(a == nullptr || b == nullptr)return false;
        if(a->val != b->val)return false;
        return dfs(a->left, b->right) && dfs(a->right, b->left);
    }
    bool isSymmetric(TreeNode* root) {
        if(root == nullptr)return true;
        return dfs(root->left, root->right);
    }
};

Algorithmic ideas:

To judge whether a and B are symmetrical, the first step is to judge whether a->val, b->val are equal, the second step is to judge whether the left subtree of a and the right subtree of B are symmetrical, the right subtree of a and the left subtree of a are symmetrical, which is equivalent to two mirror traversals at the same time, so the recursive equation can be easily written out.

[Swordfinger Offer] Series:
Swordfinger Offer stack
Chain List
[Swordfinger Offer] String
[Swordfinger Offer] Find Algorithm
[Swordfinger Offer] Search algorithm (1)
[Swordfinger Offer] Search and Backtrace Algorithms