leetcode刷题_day15

二叉树的前序遍历

#include<iostream>
#include<vector>
#include<stack>
using namespace std;

//Definition for a binary tree node.
struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode() :val(0), left(nullptr), right(nullptr) {}
	TreeNode(int x) :val(x), left(nullptr), right(nullptr) {}
	TreeNode(int x, TreeNode* l, TreeNode* r) :val(x), left(l), right(r) {}
};

//总结，递归比非递归少用了一个stack，但是执行用时却大大增加了。
class Solution {
public:
	//递归，执行用时4ms，击败39.6%，内存消耗7.9MB，击败99.87%
	vector<int> preorderTraversal_1(TreeNode* root) {
		vector<int> ans;
		dfs(root, ans);
		return ans;
	}
	void dfs(TreeNode* root, vector<int>& ans)
	{
		if (root == nullptr)
			return;
		ans.push_back(root->val);
		dfs(root->left, ans);
		dfs(root->right, ans);
	}
	// 非递归，执行用时0ms，击败100%，内存消耗8MB，击败98.69%
	vector<int> preorderTraversal_2(TreeNode* root) {
		TreeNode* p = root;
		//创建一个vector存结果
		vector<int> ans;
		if (root!= nullptr)
		{
			//如果根节点不为空指针，则创建stack，并把根节点压栈
			stack<TreeNode*> st;
			st.push(p);
			//根节点压栈之后，while循环会一直取完所有按先序遍历的结果
			//直到检测到stack为空
			while (!st.empty())
			{
				//取出栈顶元素
				p = st.top();
				st.pop();
				//结果入vector
				ans.push_back(p->val);
				//右子树压栈（根据栈先入后出的特性，所以右子树先入栈）
				if (p->right != nullptr)
					st.push(p->right);
				//左子树压栈
				if (p->left != nullptr)
					st.push(p->left);

			}

		}
		return ans;
	}
};

二叉树的中序遍历

1. 递归写法（执行用时4ms，击败39.88%，内存消耗8.2MB，击败50.48%）

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ans;
        dfs(root,ans);
        return ans;
    }
    void dfs(TreeNode* root,vector<int>& ans)
    {
        if(root == nullptr)
        {
            return ;
        }
        dfs(root->left,ans);  //先遍历左子树
        ans.push_back(root->val); //然后访问根节点
        dfs(root->right,ans);    //再遍历右子树
    }
};

2. 非递归写法

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        TreeNode* p = root;
        stack<TreeNode*>stack;
        vector<int> ret;
        if(root != nullptr){
            while(!stack.empty() || p != nullptr){  // 栈不为空或者树还没有遍历完
                if(p != nullptr){       // 扫描结点p的所有左下结点并进栈
                                        // 如果右子树的节点P为空，则可以停止并弹出值。
                    stack.push(p);      // 一颗树的左边界进栈，左孩子结点进栈
                    p = p->left;
                }else{
                    p = stack.top();    // 弹出结点，并记录结点值
                    stack.pop();
                    ret.push_back(p->val);
                    p = p->right;       // 处理右子树
                }
            }
        }
        return ret;
    }
};

二叉树的后序遍历

1. 递归写法

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ans;
        dfs(root,ans);
        return ans;
    }
    void dfs(TreeNode* root, vector<int>& ans){
        if(root == nullptr)
            return;
        dfs(root->left,ans); //先遍历左子树
        dfs(root->right,ans); //再遍历右子树
        ans.push_back(root->val); //最后访问根节点
    }
};

2. 非递归写法

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) { 
    //后序遍历的结果跟前序遍历从右子树开始的结果呈逆序关系
    //建立两个栈，一个存前序遍历从右子树开始的结果，根右左
    //           一个存这个结果的逆序，左右根
    stack<TreeNode*>s1;
    stack<TreeNode*>s2;
    vector<int> ans;
    if(root!=nullptr)
    {
        TreeNode* p = root;
        s1.push(p);
        while(!s1.empty()){
            p = s1.top();
            s1.pop();
            //把s1每一次的弹出节点存到s2中，s1的弹出顺序正好与s2相反
            s2.push(p);
            //先压左子树，因为先遍历右子树
            if(p->left!=nullptr)
                s1.push(p->left);
            if(p->right!=nullptr)
                s1.push(p->right);
        }
        //从s2中取出结果
        while(!s2.empty()){
            p = s2.top();
            s2.pop();
            ans.push_back(p->val);
        }
    }
    return ans;
    }
};