20 - 二叉树（二）

1. 按之字形顺序打印二叉树

可以联想到栈的「先入后出」的特性。由于栈仅能在一端进行入栈出栈操作，因此需要定义两个栈，交替使用。

步骤如下：

• 定义两个栈s1，s2；将根结点入栈s1；
• 对于下一层，应是「从右至左」打印，因此需要遍历栈s1、访问每一个元素，并将每一元素的孩子按照「先左孩子、后右孩子」的顺序入栈s2；将访问的结点保存；
• 对于下一层，应是「从左至右」打印，因此需要遍历栈s2、访问每一个元素，并将每一元素的孩子按照「先右孩子、后左孩子」的顺序入栈s1；将访问的结点保存；
• 重复上述操作，直至两个栈全为空。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
  public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> result;
        stack<TreeNode*> s1;//存放奇数行
        stack<TreeNode*> s2;//存放偶数行
        if (pRoot == nullptr) return result;
        s1.push(pRoot);
        int pos = 1;

        while (!s1.empty() || !s2.empty()) {
            vector<int> vec;
            if (pos) {
                int size = s1.size();
                for (int i = 0; i < size; ++i) {
                    TreeNode* node = s1.top();
                    s1.pop();
                    vec.push_back(node->val);
                    if(node->left) s2.push(node->left);
                    if(node->right) s2.push(node->right);
                }
                pos--;
            }
            else{
                int size = s2.size();
                for(int i = 0; i < size; ++i){
                    TreeNode* node = s2.top();
                    s2.pop();
                    vec.push_back(node->val);
                    if(node->right) s1.push(node->right);
                    if(node->left) s1.push(node->left);
                }
                pos++;
            }
            result.push_back(vec);
        }
        return result;
    }
};

2. 二叉树中和为某一值的路径

递归法

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        // write code here
        if(root == nullptr) return false;
        if(root->left == nullptr && root->right == nullptr){
            if(root->val == sum)
            {
                return true;
            }
        }
        return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
    }
};

3. 二叉搜索树与双向链表

dfs(cur): 递归法中序遍历

• 终止条件： 当节点 cur 为空，代表越过叶节点，直接返回；
• 递归左子树，即 dfs(cur->left) ；
• 构建链表：
  1. 当 pre 为空时： 代表正在访问链表头节点，记为 head ；
  2. 当 pre 不为空时： 修改双向节点引用，即 pre->right = cur ， cur->left = pre ；
  3. 保存 cur ： 更新 pre = cur ，即节点 cur 是后继节点的 pre ；
• 递归右子树，即 dfs(cur->right) ；

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    TreeNode* Convert(TreeNode* pRootOfTree) {
		dfs(pRootOfTree);
		return head;
    }
private:
	TreeNode* pre = nullptr;
	TreeNode* head = nullptr;
	void dfs(TreeNode* cur){
		if(cur == nullptr) return;
		dfs(cur->left);
		if(pre == nullptr){
			head = cur;
		}
		else{
			pre->right = cur;
		}
		cur->left = pre;
		pre = cur;
		dfs(cur->right);
	}
};