给出一棵二叉树，返回其节点值的前序遍历。
样例
样例 1:
输入：{1,2,3}
输出：[1,2,3]
解释：
1
/
2 3
它将被序列化为{1,2,3}
前序遍历
样例 2:
输入：{1,#,2,3}
输出：[1,2,3]
解释：
1
2
/
3
它将被序列化为{1,#,2,3}
前序遍历
挑战
你能使用非递归实现么？
/**
* Definition of TreeNode:
* class TreeNode {
* public:
* int val;
* TreeNode *left, *right;
* TreeNode(int val) {
* this->val = val;
* this->left = this->right = NULL;
* }
* }
*/
class Solution {
public:
/**
* @param root: A Tree
* @return: Preorder in ArrayList which contains node values.
*/
vector<int> res;
vector<int> preorderTraversal(TreeNode * root) {
// write your code here
// 递归方式
// if (root == NULL){
// return res;
// }
// res.push_back(root->val);
// if(root->left){
// preorderTraversal(root->left);
// }
// if(root->right){
// preorderTraversal(root->right);
// }
// return res;
// 非递归方式
if (root == NULL){
return res;
}
stack<TreeNode *> node;
node.push(root);
while(!node.empty()){
TreeNode * temp = node.top();
res.push_back(temp->val);
node.pop();
if(temp->right){
node.push(temp->right);
}
if(temp->left){
node.push(temp->left);
}
}
return res;
}
};
给出一棵二叉树,返回其中序遍历
样例
样例 1:
输入：{1,2,3}
输出：[2,1,3]
解释：
1
/
2 3
它将被序列化为{1,2,3}
中序遍历
样例 2:
输入：{1,#,2,3}
输出：[1,3,2]
解释：
1
2
/
3
它将被序列化为{1,#,2,3}
中序遍历
挑战
你能使用非递归算法来实现么?
/**
* Definition of TreeNode:
* class TreeNode {
* public:
* int val;
* TreeNode *left, *right;
* TreeNode(int val) {
* this->val = val;
* this->left = this->right = NULL;
* }
* }
*/
class Solution {
public:
/**
* @param root: A Tree
* @return: Inorder in ArrayList which contains node values.
*/
vector<int> res;
vector<int> inorderTraversal(TreeNode * root) {
// write your code here
//递归方式
// if(root==NULL){
// return res;
// }
// if(root->left){
// inorderTraversal(root->left);
// }
// res.push_back(root->val);
// if(root->right){
// inorderTraversal(root->right);
// }
// return res;
//非递归方式
if(root==NULL){
return res;
}
stack<TreeNode*> node;
while(!node.empty()||root!=NULL){
if(root!=NULL){
//根节点入栈然后不断入栈左子节点，直到为空
node.push(root);
root=root->left;
}else{
TreeNode * temp= node.top();
node.pop();
res.push_back(temp->val);
//注意这里不是root = root->right ，因为此时的root 本身已经是NULL，所以是不存在任何节点信息的，应该用栈顶元素temp去赋值
root = temp->right;
}
}
return res;
}
};
给出一棵二叉树，返回其节点值的后序遍历。
样例
样例 1:
输入：{1,2,3}
输出：[2,3,1]
解释：
1
/
2 3
它将被序列化为{1,2,3}
后序遍历
样例 2:
输入：{1,#,2,3}
输出：[3,2,1]
解释：
1
2
/
3
它将被序列化为{1,#,2,3}
后序遍历
挑战
你能使用非递归实现么？
/**
* Definition of TreeNode:
* class TreeNode {
* public:
* int val;
* TreeNode *left, *right;
* TreeNode(int val) {
* this->val = val;
* this->left = this->right = NULL;
* }
* }
*/
class Solution {
public:
/**
* @param root: A Tree
* @return: Postorder in ArrayList which contains node values.
*/
vector<int> res;
vector<int> postorderTraversal(TreeNode * root) {
// write your code here
// 递归方式
// if (root==NULL){
// return res;
// }
// if(root->left){
// postorderTraversal(root->left);
// }
// if(root->right){
// postorderTraversal(root->right);
// }
// res.push_back(root->val);
// return res;
// 非递归方式
if (root==NULL){
return res;
}
stack<TreeNode *> node;
//当前节点
TreeNode * cur;
//前一次访问的结点
TreeNode *pre=NULL;
node.push(root);
while(!node.empty()){
cur = node.top();
//如果当前结点没有孩子结点或者孩子节点都已被访问过
if((cur->left==NULL&&cur->right==NULL)||(pre!=NULL&&(pre==cur->left||pre==cur->right)))
{
res.push_back(cur->val);
node.pop();
pre=cur;
}
else{
if(cur->right){
node.push(cur->right);
}
if(cur->left){
node.push(cur->left);
}
}
}
return res;
}
};
给出一棵二叉树，返回其节点值的层次遍历（逐层从左往右访问）
样例
样例 1:
输入：{1,2,3}
输出：[[1],[2,3]]
解释：
1
/
2 3
它将被序列化为{1,2,3}
层次遍历
样例 2:
输入：{1,#,2,3}
输出：[[1],[2],[3]]
解释：
1
2
/
3
它将被序列化为{1,#,2,3}
层次遍历
挑战
挑战1：只使用一个队列去实现它
挑战2：用BFS算法来做
/**
* Definition of TreeNode:
* class TreeNode {
* public:
* int val;
* TreeNode *left, *right;
* TreeNode(int val) {
* this->val = val;
* this->left = this->right = NULL;
* }
* }
*/
class Solution {
public:
/**
* @param root: A Tree
* @return: Level order a list of lists of integer
*/
vector<vector<int>> levelOrder(TreeNode * root) {
// write your code here
//最终的res长度的行数其实也是二叉树的深度
vector<vector<int>> res;
if(root==NULL){
return res;
}
//采用广度优先遍历，用队列来实现
queue<TreeNode *> q;
// 这里需要结果集合是一个二维vector,所以需要额外定义一个变量记录每一层的节点个数
int len;
q.push(root);
while(!q.empty()){
len = q.size();
vector<int> level;
while(len>0){
TreeNode *temp = q.front();
level.push_back(temp->val);
q.pop();
len--;
if(temp->left){
q.push(temp->left);
}
if(temp->right){
q.push(temp->right);
}
}
res.push_back(level);
}
return res;
}
};
给出一棵二叉树，返回其节点值从底向上的层次序遍历（按从叶节点所在层到根节点所在的层遍历，然后逐层从左往右遍历）
样例
例1:
输入:
{1,2,3}
输出:
[[2,3],[1]]
解释:
1
/
2 3
它将被序列化为 {1,2,3}
层次遍历
例2:
输入:
{3,9,20,#,#,15,7}
输出:
[[15,7],[9,20],[3]]
解释:
3
/
9 20
/
15 7
它将被序列化为 {3,9,20,#,#,15,7}
层次遍历
二叉树相关题目思路分析：
https://blog.csdn.net/luckyxiaoqiang/article/details/7518888
链表相关题目分析：
https://blog.csdn.net/walkinginthewind/article/details/7393134
博主系列博客，可以多关注一下。