廣度優先搜索

1、把根節點入隊列；
2、如果隊列非空，出隊，再依次將左子樹入隊、右子樹入隊；
3、重復步驟2，直到隊列為空。

void BreadFirstSearch(TreeNode *root){
    if(root == NULL)
        return;
    queue<TreeNode*> q;
    q.push(root);
    TreeNode* node;
    while(!q.empty()){
        node = q.front();
        cout << node->val << " ";
        q.pop();
        if(node->left)
            q.push(node->left);
        if(node->right)
            q.push(node->right);
    }
}
 

深度優先搜索

1、把根節點入棧；
2、如果棧非空，則出棧，再依次將右子樹入棧、左子樹入棧；
3、重復步驟2，直到棧為空。

void DepthFirtstSearch(TreeNode* root){
    if(root == NULL)
        return;
    stack<TreeNode*> ss;
    ss.push(root);
    TreeNode* node;
    while(!ss.empty()){
        node = ss.top();
        cout << ss->val << " ";
        ss.pop();
        if(node->right)
            ss.push(node->right);
        if(node->left)
            ss.push(node->left);
    }
}
 

二叉樹鏡像

方法1：遞歸實現，先把根節點的左右子樹交換，再對左子樹、右子樹進行同樣的操作。

class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if(pRoot == NULL)
            return;
        TreeNode *temp;
        temp = pRoot->left;
        pRoot->left = pRoot->right;
        pRoot->right = temp;
        Mirror(pRoot->left);
        Mirror(pRoot->right);
    }
};
 

方法2：非遞歸，既可以用隊列輔助，也可以用棧輔助。如果用隊列，先把根節點的左右子樹交換，然後把左右子樹入隊列，每次取出隊首元素，交換左右子樹，直到隊列為空。

class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if(pRoot == NULL)
            return;
        queue<TreeNode*> qq;
        qq.push(pRoot);
        TreeNode *node, *temp;
        while(!qq.empty()){
            node = qq.front();
            temp = node->left;
            node->left = node->right;
            node->right = temp;
            qq.pop();
            if(node->left)
                qq.push(node->left);
            if(node->right)
                qq.push(node->right);
        }
    }
};

如果用棧，則先把根節點的左右子樹交換，然後把左右子樹分別入棧，每次取棧頂元素，交換左右子樹，直到棧為空。

class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if(pRoot == NULL)
            return;
        stack<TreeNode*> ss;
        TreeNode *node, *temp;
        ss.push(pRoot);
        while(!ss.empty()){
            node = ss.top();
            ss.pop();
            temp = node->left;
            node->left = node->right;
            node->right = temp;
            if(node->left)
                ss.push(node->left);
            if(node->right)
                ss.push(node->right);
        }
    }
};

二叉樹基本操作