python 二叉树遍历非递归_leetcode 501. Find Mode in Binary Search Tree | 二叉树遍历(递归和非递归实现)...

Description

Given a binary search tree (BST) with duplicates, find all the mode(s) (the most frequently occurred element) in the given BST.

Assume a BST is defined as follows:

The left subtree of a node contains only nodes with keys less than or equal to the node's key.

The right subtree of a node contains only nodes with keys greater than or equal to the node's key.

Both the left and right subtrees must also be binary search trees.

For example:

Given BST [1,null,2,2],

1

\

2

/

2

return [2].

Note: If a tree has more than one mode, you can return them in any order.

Follow up: Could you do that without using any extra space? (Assume that the implicit stack space incurred due to recursion does not count).

My solution

// 全部存储的笨办法, 没有利用二叉搜索树的特点.

class Solution {

public:

vector findMode(TreeNode *root) {

vector res;

if(!root) return res;

unordered_map mp;

stack s;

s.push(root);

while (!s.empty()) {

root = s.top();

s.pop();

++mp[root->val];

if (root->right) s.push(root->right);

if (root->left) s.push(root->left);

}

int maxcnt = 0;

for (auto mmp:mp) {

maxcnt = max(mmp.second, maxcnt);

}

for (auto mmp:mp) {

if (mmp.second == maxcnt) res.push_back(mmp.first);

}

return res;

}

};

Discuss

Obviously, it is very easy to get modes from a sorted array since all duplicates are consecutive. An in-order traversal of BST gives exactly a sorted sequence.

public class Solution {

public int[] findMode(TreeNode root) {

inorder(root);

modes = new int[modeCount];

modeCount = 0;

currCount = 0;

inorder(root);

return modes;

}

private int currVal;

private int currCount = 0;

private int maxCount = 0;

private int modeCount = 0;

private int[] modes;

private void handleValue(int val) {

if (val != currVal) {

currVal = val;

currCount = 0;

}

currCount++;

if (currCount > maxCount) {

maxCount = currCount;

modeCount = 1;

} else if (currCount == maxCount) {

if (modes != null)

modes[modeCount] = currVal;

modeCount++;

}

}

private void inorder(TreeNode root) {

if (root == null) return;

inorder(root.left);

handleValue(root.val);

inorder(root.right);

}

}

二叉树遍历问题

犹记上次去网易有道面试, 二叉树中序非递归没写出来的尴尬, 下面总结一波:

void visit(TreeNode *root) {

cout << root->val << " ";

}

递归

因为前中后的遍历是按照递归思想定义的, 所以递归的方式实现起来很easy, 并且相差不大.

### pre order

void preorder(TreeNode* root){

if(!root) return;

visit(root);

preorder(root->left);

preorder(root->right);

}

### in order

void inorder(TreeNode* root){

if(!root) return;

inorder(root->left);

visit(root);

inorder(root->right);

}

### post order

void postorder(TreeNode* root){

if(!root) return;

postorder(root->left);

postorder(root->right);

visit(root);

}

非递归

非递归实现起来, 从pre->in->post 一个比一个难...

pre order

和递归形式接近的方式

void preorder_likedigui(TreeNode *root) {

if (!root) return;

stack s;

s.push(root);

while (!s.empty()) {

root = s.top();

s.pop();

visit(root);

if (root->right) s.push(root->right);

if (root->left) s.push(root->left);

}

}

回溯

void preorder_huisu(TreeNode *root) {

if (!root) return;

stack s;

while (root || !s.empty()) {

if (root) {

visit(root);

s.push(root);

root = root->left;

} else {

root = s.top();

s.pop();

root = root->right;

}

}

}

in order

回溯

void inorder_huisu(TreeNode *root) {

if (!root) return;

stack s;

while (root || !s.empty()){

if(root){

s.push(root);

root=root->left;

}else{

root=s.top();

s.pop();

visit(root);

root=root->right;

}

}

}

post order

简易但是需要额外空间的方式

void postorder_huisu_extrastack(TreeNode *root) {

if (!root) return;

stack s, sextra;

s.push(root);

while (!s.empty()) {

root = s.top();

s.pop();

//visit(root);

sextra.push(root);

if (root->right) s.push(root->right);

if (root->left) s.push(root->left);

}

while(!sextra.empty()){

visit(sextra.top());

sextra.pop();

}

}

回溯 | 更复杂一些的方法(递归转非递归看来没有很容易的通用方式..)

void postorder_huisu(TreeNode *root) {

if (!root) return;

stack s;

TreeNode *lastVist = NULL;

while (root || !s.empty()) {

if (root) {

s.push(root);

root = root->left;

} else {

root = s.top();

if (root->right && lastVist != root->right) {

root = root->right;

} else {

s.pop();

visit(root);

lastVist = root;

root = NULL;

}

}

}

}

*回溯另一种常见写法

回溯的方法还有常见的另一种写法,区别在于left->left->left..时使用while一次性到底, 我上面的代码是利用外层while, 两种方式都挺直观. 如下:

// 非递归后序遍历

public static void postorderTraversal(TreeNode root) {

Stack treeNodeStack = new Stack();

TreeNode node = root;

TreeNode lastVisit = root;

while (node != null || !treeNodeStack.isEmpty()) {

while (node != null) {

treeNodeStack.push(node);

node = node.left;

}

//查看当前栈顶元素

node = treeNodeStack.peek();

//如果其右子树也为空，或者右子树已经访问

//则可以直接输出当前节点的值

if (node.right == null || node.right == lastVisit) {

System.out.print(node.val + " ");

treeNodeStack.pop();

lastVisit = node;

node = null;

} else {

//否则，继续遍历右子树

node = node.right;

}

}

}

作者：jjs4500

链接：http://www.jianshu.com/p/456af5480cee

來源：简书

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Test Result