LeetCode—— Binary Tree Traversal

二叉树遍历的三道题

Binary Tree Preorder Traversal

Binary Tree Inorder Traversal

Binary Tree Postorder Traversal

LeetCode 上二叉树的节点定义如下:

// 树的节点 struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) { }
};

常规递归算法

/**
* 递归先序遍历
*/
void preOrder_traverse_recur(BiTree T) {
if(T == NULL) {
return;
} else {
printf("%d", T->val);
preOrder_traverse_recur(T->left);
preOrder_traverse_recur(T->right);
}
}

/**
* 递归中序遍历
*/
void inOrder_traverse_recur(BiTree T) {
if(T == NULL) {
return;
} else {
inOrder_traverse_recur(T->left);
printf("%d", T->val);
inOrder_traverse_recur(T->right);
}
}

/**
* 递归后序遍历
*/
void postOrder_traverse_recur(BiTree T) {
if(T == NULL) {
return;
} else {
postOrder_traverse_recur(T->left);
postOrder_traverse_recur(T->right);
printf("%d", T->val);
}
}

栈 算法

时间复杂度 O(n),空间复杂度 O(n)

// LeetCode, Binary Tree Preorder Traversal
class Solution {
public:
vector<int> preorderTraversal(TreeNode *root) {
vector<int> result;
const TreeNode *p;
stack<const TreeNode *> s;
p = root;
if (p != nullptr) s.push(p);
while (!s.empty()) {
p = s.top();
s.pop();
result.push_back(p->val);
if (p->right != nullptr) s.push(p->right);
if (p->left != nullptr) s.push(p->left);
}
return result;
}
};

// LeetCode, Binary Tree Inorder Traversal
class Solution {
public:
vector<int> inorderTraversal(TreeNode *root) {
vector<int> result;
const TreeNode *p = root;
stack<const TreeNode *> s;
while (!s.empty() || p != nullptr) {
if (p != nullptr) {
s.push(p);
p = p->left;
} else {
p = s.top();
s.pop();
result.push_back(p->val);
p = p->right;
} }
return result;
}
};

// LeetCode, Binary Tree Postorder Traversal
class Solution {
public:
vector<int> postorderTraversal(TreeNode *root) { vector<int> result;
/* p,正在访问的结点,q,刚刚访问过的结点 */
const TreeNode *p, *q;
stack<const TreeNode *> s;
p = root;
do {
while (p != nullptr) { /* 往左下走 */
s.push(p);
p = p->left;
}
q = nullptr;
while (!s.empty()) {
p = s.top();
s.pop();
/* 右孩子不存在或已被访问,访问之 */
if (p->right == q) {
result.push_back(p->val);
q = p; /* 保存刚访问过的结点 */
} else {
/* 当前结点不能访问,需第二次进栈 */
s.push(p);
/* 先处理右子树 */
p = p->right;
break;
}
}
} while (!s.empty());
return result;
}
};

Morris算法

时间复杂度 O(n),空间复杂度 O(1)

参考：http://www.tuicool.com/articles/zA7NJbj

算法伪码（Morris InOrder) :

while 节点非空
if 当前节点没有左子树
访问该节点
转向右节点
else
找到左子树的最右节点
if 最右子节点指空
最右节点的右指针指向根
转向左子树节点
else //最右子节点指根
消除指根指针
根节点右移

C++实现：

Morris 中序遍历

void morris_inorder(TreeNode *root) {
TreeNode *p = root, *tmp;
while (p) {
if (p->left == NULL) {
printf("%d ", p->key);
p = p->right;
}
else {
tmp = p->left;
while (tmp->right != NULL && tmp->right != p)
tmp = tmp->right;
if (tmp->right == NULL) {
tmp->right = p;
p = p->left;
} else {
printf("%d ", p->key);
tmp->right = NULL;
p = p->right;
}
}
}
}

Morris 先序遍历

void morris_preorder(TreeNode *root) {
TreeNode *p = root, *tmp;
while (p) {
if (p->left == NULL) {
printf("%d ",p->key);
p = p->right;
} else {
tmp = p->left;
while (tmp->right != NULL && tmp->right != p) {
tmp = tmp->right;
}
if (tmp->right == NULL){
print("%d ",p->key);
tmp->right = p;
p = p->left;
} else {
tmp->right = NULL;
p = p->right;
}
}
}
}

Morris后序遍历二叉树的算法与上面的算法思想一致，只是在遍历前，增加了一个类似头节点的节点作为整个遍历过程的起始节点。

/**
* morris后序遍历算法
*/
void morris_postOrder(BiTree T) {
BNode *dump = malloc(sizeof(BNode));
BNode *p, *temp;
dump->left = T;
p = dump;
while(p) {
if(p->left == NULL) {
p = p->right;
} else {
temp = p->left;
while(temp->right != NULL && temp->right != p) {
temp = temp->right;
}
if(temp->right == NULL) {
temp->right = p;
p = p->left;
} else {
printReverse(p->left, temp);
temp->right = NULL;
p = p->right;
}
}
}
free(dump);
}

代码中的printReverse()函数就是逆序遍历从p->left到temp这条路径上的节点的过程;

printReverse函数先将从from节点到to节点的这条路径反转，再输出，最后还原.

/**
* 相当于单链表的反转
*/
void reverse(BNode *from, BNode *to) {
BNode *x, *y, *z;
if(from == to) {
return;
}
x = from;
y = from->right;
while(x != to) {
z = y->right;
y->right = x;
x = y;
y = z;
}
}

void printReverse(BNode *from , BNode *to) {
BNode *p;
reverse(from, to);
p = to;
while(1) {
printf("%4c", p->ch);
if(p == from) {
break;
}
p = p->right;
}
reverse(to, from);
}