[LeetCode_94] Binary Tree Inorder Traversal

###题目链接
https://leetcode.com/problems/binary-tree-inorder-traversal/

###题意
二叉树的中序遍历

###代码(递归,C++)
其中函数返回类型不符合题目中要求，做相应更改即可A；

/**
 * 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:
    vector<int> inorderVec;
    void inorderTraversal(TreeNode* root) {
        if(root==NULL){
            return;
        }

        if(root->left){
            inorderTraversal(root->left);
        }
        inorderVec.push_back(root->val);
        if(root->right){
            inorderTraversal(root->right);
        }
    }
};

###相关
####二叉树的中序遍历非递归版
#####思路：

• 当栈不为空或当前节点不为空：一路将左孩子压入栈直到当前节点为空，然后弹出栈顶元素并将它加入输出队列，将当前节点更新为其右孩子；再继续一路向左...

#####代码(Java)

class Solution {
	public List<Integer> inorderTraversal(TreeNode root) {
		List<Integer> list = new ArrayList<>();
		Stack<TreeNode> stack = new Stack<>();

		if (root == null) {
			return list;
		}

		TreeNode cur = root;
		while (cur != null || !stack.isEmpty()) { //
			while (cur != null) {
				stack.push(cur);
				cur = cur.left;
			}
			cur = stack.pop();
			list.add(cur.val);
			cur = cur.right;//

		}

		return list;
	}
}

####二叉树的先序遍历非递归版
#####思路：

• 使用栈。
• 具体的，
  • 先把根节点压栈。
  • while(栈非空){栈顶元素弹出并打印，若其右孩子非空则入栈，若其左孩子非空则压栈}

#####代码(Java)

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> l=new ArrayList<>();
        Stack<TreeNode> s=new Stack<>();
		if(root==null) {
			return l;
		}
		s.add(root);

		while(!s.empty()) {
			TreeNode node=s.pop();
			l.add(node.val);
			if(node.right!=null) {
				s.push(node.right);
			}
			if(node.left!=null) {
				s.push(node.left);
			}
		}
        return l;
    }
}

####二叉树的后序遍历非递归版
#####思路：

• 变量dealedNode代表最近一个加入到输出队列的节点，stacktopNode记录当前栈顶节点。
• 因为后序遍历要三次到达每个节点，在第三次才输出当前节点，所以根据栈顶元素的左孩子和右孩子是否刚处理完是否为空，分三种情况做下一步操作。
  • 具体的，每次循环更新栈顶元素变量。
  • 一 若上一个处理完的节点不是栈顶元素的左孩子也不是当前栈顶元素的右孩子，说明是第一次到达该节点，若栈顶元素左孩子不为空则压入左孩子
  • 二 若不符合上一条，且上一个处理完的节点不是栈顶元素的右孩子（等价于 上一个处理完的是栈顶元素的左孩子或栈顶元素的左孩子为null），则说明是第二次到达该节点，若栈顶元素右孩子不为空则压入右孩子。
  • 三 若不符合上两条，说明是第三次到达该节点，将该节点弹出，处理该节点（及将该节点加入输出队列），更新dealedNode变量。
  • 终止条件：栈为空

#####代码(Java)

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {

		List<Integer> l=new ArrayList<>();
	        Stack<TreeNode> s=new Stack<>();
			if(root==null) {
				return l;
			}

			TreeNode dealedNode=root;
			s.add(root);
			TreeNode stackTopNode;

	        while(!s.empty()) {
	        	stackTopNode=s.peek();
	        	if(dealedNode!=stackTopNode.left&&dealedNode!=stackTopNode.right&&stackTopNode.left!=null) {
	        		s.add(stackTopNode.left);
	        	}
	        	else if(dealedNode!=stackTopNode.right&&stackTopNode.right!=null) {
	        		s.add(stackTopNode.right);
	        	}
	        	else {
	        		s.pop();
	        		l.add(stackTopNode.val);
	        		dealedNode=stackTopNode;
	        	}
	        }

	        return l;
    }
}

####二叉树的层序遍历

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> l=new ArrayList<>();
		LinkedList<TreeNode> q=new LinkedList<>();
		if(root!=null) {
			q.add(root);
			while(!q.isEmpty()) {
				TreeNode temproot=q.poll();
				l.add(temproot.val);
				if(temproot.left!=null) {
					q.add(temproot.left);
				}
				if(temproot.right!=null) {
					q.add(temproot.right);
				}
			}
		}
		return l;
    }
}