訪問済みフラグを使用せずに他の2つのソリューションを提供するリンクを次に示します。
https://leetcode.com/problems/binary-tree-postorder-traversal/
これは、ツリー内に親ポインターがないため、明らかにスタックベースのソリューションです。 （親ポインターがある場合、スタックは必要ありません）。
最初にルートノードをスタックにプッシュします。スタックは空ではありませんが、スタックの先頭からノードの左の子をプッシュし続けます。左の子が存在しない場合、右の子をプッシュします。リーフノードの場合、ノードを処理し、スタックからポップします。
また、変数を使用して、以前にトラバースしたノードを追跡します。目的は、トラバーサルがツリーを下降/上昇しているかどうかを判断することです。また、左/右から上昇しているかどうかを知ることもできます。
ツリーを左から上に上げる場合、その左の子を再びスタックにプッシュしたくないため、右の子が存在する場合はツリーを下に昇り続ける必要があります。ツリーを右から上に移動する場合、それを処理してスタックからポップする必要があります。
次の3つの場合、ノードを処理してスタックからポップします。
- ノードはリーフノードです（子はありません）
- 左からツリーを上に移動するだけで、右の子は存在しません。
- 右からツリーをたどるだけです。
スタックが1つあり、訪問済みフラグがないバージョンを次に示します。
private void postorder(Node head) {
if (head == null) {
return;
}
LinkedList<Node> stack = new LinkedList<Node>();
stack.Push(head);
while (!stack.isEmpty()) {
Node next = stack.peek();
boolean finishedSubtrees = (next.right == head || next.left == head);
boolean isLeaf = (next.left == null && next.right == null);
if (finishedSubtrees || isLeaf) {
stack.pop();
System.out.println(next.value);
head = next;
}
else {
if (next.right != null) {
stack.Push(next.right);
}
if (next.left != null) {
stack.Push(next.left);
}
}
}
}
wikipedia のサンプルを次に示します。
nonRecursivePostorder(rootNode)
nodeStack.Push(rootNode)
while (! nodeStack.empty())
currNode = nodeStack.peek()
if ((currNode.left != null) and (currNode.left.visited == false))
nodeStack.Push(currNode.left)
else
if ((currNode.right != null) and (currNode.right.visited == false))
nodeStack.Push(currNode.right)
else
print currNode.value
currNode.visited := true
nodeStack.pop()
これは、繰り返しのポストオーダートラバーサルに使用するアプローチです。私はこのアプローチが好きです：
- ループサイクルごとに1つの遷移のみを処理するため、簡単に追跡できます。
- 同様の解決策は、順方向および事前順のトラバーサルで機能します
コード：
enum State {LEFT, RIGHT, UP, CURR}
public void iterativePostOrder(Node root) {
Deque<Node> parents = new ArrayDeque<>();
Node curr = root;
State state = State.LEFT;
while(!(curr == root && state == State.UP)) {
switch(state) {
case LEFT:
if(curr.left != null) {
parents.Push(curr);
curr = curr.left;
} else {
state = RIGHT;
}
break;
case RIGHT:
if(curr.right != null) {
parents.Push(curr);
curr = curr.right;
state = LEFT;
} else {
state = CURR;
}
break;
case CURR:
System.out.println(curr);
state = UP;
break;
case UP:
Node child = curr;
curr = parents.pop();
state = child == curr.left ? RIGHT : CURR;
break;
default:
throw new IllegalStateException();
}
}
}
説明：
次のような手順について考えることができます。
- LEFT をお試しください
- 左ノードが存在する場合：もう一度LEFTを試してください
- 左ノードが存在しない場合：RIGHTを試してください
- RIGHT をお試しください
- 適切なノードが存在する場合：そこからLEFTを試してください
- 権利が存在しない場合、あなたはリーフにいます：CURRを試してください
- CURR を試してください
- 現在のノードを印刷
- 以下のすべてのノードが実行されました（ポストオーダー）：試してみてください
- やってみて
- ノードがルートの場合、UPはないため、EXIT
- 左から上に来る場合は、RIGHTを試してください
- 右から来る場合は、CURRを試してください
以下は、ツリーでのブックキーピングにストレージを必要としないC++のソリューションです。
代わりに、2つのスタックを使用します。 1つはノードのトラバースを支援し、もう1つはノードのポストトラバーサルを実行できるようにノードを保存します。
std::stack<Node*> leftStack;
std::stack<Node*> rightStack;
Node* currentNode = m_root;
while( !leftStack.empty() || currentNode != NULL )
{
if( currentNode )
{
leftStack.Push( currentNode );
currentNode = currentNode->m_left;
}
else
{
currentNode = leftStack.top();
leftStack.pop();
rightStack.Push( currentNode );
currentNode = currentNode->m_right;
}
}
while( !rightStack.empty() )
{
currentNode = rightStack.top();
rightStack.pop();
std::cout << currentNode->m_value;
std::cout << "\n";
}
import Java.util.Stack;
public class IterativePostOrderTraversal extends BinaryTree {
public static void iterativePostOrderTraversal(Node root){
Node cur = root;
Node pre = root;
Stack<Node> s = new Stack<Node>();
if(root!=null)
s.Push(root);
System.out.println("sysout"+s.isEmpty());
while(!s.isEmpty()){
cur = s.peek();
if(cur==pre||cur==pre.left ||cur==pre.right){// we are traversing down the tree
if(cur.left!=null){
s.Push(cur.left);
}
else if(cur.right!=null){
s.Push(cur.right);
}
if(cur.left==null && cur.right==null){
System.out.println(s.pop().data);
}
}else if(pre==cur.left){// we are traversing up the tree from the left
if(cur.right!=null){
s.Push(cur.right);
}else if(cur.right==null){
System.out.println(s.pop().data);
}
}else if(pre==cur.right){// we are traversing up the tree from the right
System.out.println(s.pop().data);
}
pre=cur;
}
}
public static void main(String args[]){
BinaryTree bt = new BinaryTree();
Node root = bt.generateTree();
iterativePostOrderTraversal(root);
}
}
// Javaフラグ付きバージョン
public static <T> void printWithFlag(TreeNode<T> root){
if(null == root) return;
Stack<TreeNode<T>> stack = new Stack<TreeNode<T>>();
stack.add(root);
while(stack.size() > 0){
if(stack.peek().isVisit()){
System.out.print(stack.pop().getValue() + " ");
}else{
TreeNode<T> tempNode = stack.peek();
if(tempNode.getRight()!=null){
stack.add(tempNode.getRight());
}
if(tempNode.getLeft() != null){
stack.add(tempNode.getLeft());
}
tempNode.setVisit(true);
}
}
}
この完全なJavaの実装を参照してください。コードをコピーしてコンパイラに貼り付けてください。正常に動作します。
import Java.util.LinkedList;
import Java.util.Queue;
import Java.util.Stack;
class Node
{
Node left;
String data;
Node right;
Node(Node left, String data, Node right)
{
this.left = left;
this.right = right;
this.data = data;
}
public String getData()
{
return data;
}
}
class Tree
{
Node node;
//insert
public void insert(String data)
{
if(node == null)
node = new Node(null,data,null);
else
{
Queue<Node> q = new LinkedList<Node>();
q.add(node);
while(q.peek() != null)
{
Node temp = q.remove();
if(temp.left == null)
{
temp.left = new Node(null,data,null);
break;
}
else
{
q.add(temp.left);
}
if(temp.right == null)
{
temp.right = new Node(null,data,null);
break;
}
else
{
q.add(temp.right);
}
}
}
}
public void postorder(Node node)
{
if(node == null)
return;
postorder(node.left);
postorder(node.right);
System.out.print(node.getData()+" --> ");
}
public void iterative(Node node)
{
Stack<Node> s = new Stack<Node>();
while(true)
{
while(node != null)
{
s.Push(node);
node = node.left;
}
if(s.peek().right == null)
{
node = s.pop();
System.out.print(node.getData()+" --> ");
if(node == s.peek().right)
{
System.out.print(s.peek().getData()+" --> ");
s.pop();
}
}
if(s.isEmpty())
break;
if(s.peek() != null)
{
node = s.peek().right;
}
else
{
node = null;
}
}
}
}
class Main
{
public static void main(String[] args)
{
Tree t = new Tree();
t.insert("A");
t.insert("B");
t.insert("C");
t.insert("D");
t.insert("E");
t.postorder(t.node);
System.out.println();
t.iterative(t.node);
System.out.println();
}
}
これは、一般的なツリーの場合にPython。ノードと子のリストスタックは1つだけです。使用例を示します。
def postorder(tree):
def do_something(x): # Your function here
print(x),
def walk_helper(root_node, calls_to_perform):
calls_to_perform.append(partial(do_something, root_node[0]))
for child in root_node[1]:
calls_to_perform.append(partial(walk_helper, child, calls_to_perform))
calls_to_perform = []
calls_to_perform.append(partial(walk_helper, tree, calls_to_perform))
while calls_to_perform:
calls_to_perform.pop()()
postorder(('a', [('b', [('c', []), ('d', [])])]))
d c b a
Python version too ::
class Node:
def __init__(self,data):
self.data = data
self.left = None
self.right = None
def postOrderIterative(root):
if root is None :
return
s1 = []
s2 = []
s1.append(root)
while(len(s1)>0):
node = s1.pop()
s2.append(node)
if(node.left!=None):
s1.append(node.left)
if(node.right!=None):
s1.append(node.right)
while(len(s2)>0):
node = s2.pop()
print(node.data)
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
root.right.left = Node(6)
root.right.right = Node(7)
postOrderIterative(root)
出力は次のとおりです::
再帰を使用しないPost Order Traversalのロジック
Postorder traversal、処理順序はleft-right-current。そのため、他の部分にアクセスする前に、まず左側のセクションにアクセスする必要があります。ツリーの各ノードについて、できるだけ左にツリーをたどろうとします。現在の各ノードについて、適切な子が存在する場合、ルートにNULL/Noneでないときに現在のノードをプッシュする前にスタックにプッシュします。スタックからノードをポップし、そのノードの適切な子が存在するかどうかを確認します。存在する場合は、最上位要素と同じかどうかを確認します。それらが同じである場合、正しい部分がまだ完了していないことを示しているため、現在のノードを処理する前に、適切な部分を処理し、そのために最上部の要素（右の子）をポップし、現在のノードをスタックにプッシュする必要があります。毎回、頭がポップされた要素になります。現在の要素がtopと同じでなく、headがNULLでない場合、左セクションと右セクションの両方で処理が完了するので、現在のノードを処理できます。スタックが空になるまで、前の手順を繰り返す必要があります。
def Postorder_iterative(head):
if head is None:
return None
sta=stack()
while True:
while head is not None:
if head.r:
sta.Push(head.r)
sta.Push(head)
head=head.l
if sta.top is -1:
break
head = sta.pop()
if head.r is not None and sta.top is not -1 and head.r is sta.A[sta.top]:
x=sta.pop()
sta.Push(head)
head=x
else:
print(head.val,end = ' ')
head=None
print()
ノードクラスは、特に関連性のないテストケースとして追加しておらず、読者向けの演習として残しています。
void postOrderTraversal(node* root)
{
if(root == NULL)
return;
stack<node*> st;
st.Push(root);
//store most recent 'visited' node
node* prev=root;
while(st.size() > 0)
{
node* top = st.top();
if((top->left == NULL && top->right == NULL))
{
prev = top;
cerr<<top->val<<" ";
st.pop();
continue;
}
else
{
//we can check if we are going back up the tree if the current
//node has a left or right child that was previously outputted
if((top->left == prev) || (top->right== prev))
{
prev = top;
cerr<<top->val<<" ";
st.pop();
continue;
}
if(top->right != NULL)
st.Push(top->right);
if(top->left != NULL)
st.Push(top->left);
}
}
cerr<<endl;
}
実行時間O(n)-すべてのノードにアクセスする必要があり、スペースO(n)-スタックの場合、最悪の場合のツリーはリンクされた単一行ですリスト
1.1空のスタックを作成する
2.1 rootがNULLでないときに以下を実行します
a) Push root's right child and then root to stack.
b) Set root as root's left child.
2.2スタックからアイテムをポップし、ルートとして設定します。
a) If the popped item has a right child and the right child
is at top of stack, then remove the right child from stack,
Push the root back and set root as root's right child.
b) Else print root's data and set root as NULL.
2.3スタックが空でない間、ステップ2.1と2.2を繰り返します。
うまく機能し、カスタマイズが簡単なコードスニペットを探していました。スレッドツリーは「単純」ではありません。ダブルスタックソリューションには、O(n)メモリが必要です。LeetCodeソリューションおよびtcbによるソリューションには、追加のチェックとプッシュが必要です...
Cに翻訳された古典的なアルゴリズムの1つを次に示します。
void postorder_traversal(TreeNode *p, void (*visit)(TreeNode *))
{
TreeNode *stack[40]; // simple C stack, no overflow check
TreeNode **sp = stack;
TreeNode *last_visited = NULL;
for (; p != NULL; p = p->left)
*sp++ = p;
while (sp != stack) {
p = sp[-1];
if (p->right == NULL || p->right == last_visited) {
visit(p);
last_visited = p;
sp--;
} else {
for (p = p->right; p != NULL; p = p->left)
*sp++ = p;
}
}
}
私見このアルゴリズムは、パフォーマンスが良く読みやすいwikipedia.org/Tree_traversal擬似コードよりも簡単です。すばらしい詳細については、KnuthのVolume 1のバイナリツリー演習の回答をご覧ください。
この問題に対する非常に多くの活発なアプローチを見ることは非常に素晴らしいことです。本当に感動的です！
このトピックに出会ったのは、バイナリツリー実装のすべてのノードを削除するための簡単な反復ソリューションを探していたときです。私はそれらのいくつかを試し、ネット上の他の場所で見つかった同様の何かを試しましたが、それらのどれも本当に私の好みに合っていませんでした。
事は、私は非常に特定の目的（ビットコインブロックチェーンインデックス）のためのデータベースインデックスモジュールを開発しており、私のデータはRAMではなくディスクに保存されています。必要に応じてページをスワップし、独自のメモリ管理を行います。低速ですが、その目的には十分な速さであり、RAMの代わりにディスク上にストレージを持っているので、スペースを浪費することに対する宗教的な関係はありません（ハードディスクは安価です）。
そのため、バイナリツリーのノードには親ポインターがあります。それが（すべて）私が話している余分なスペースです。さまざまな目的でツリーを昇順と降順の両方で繰り返す必要があるため、親が必要です。
それを念頭に置いて、私はそれがどのように行われるかについての小さな擬似コード、つまり、その場でノードを削除する後順走査をすぐに書き留めました。実装およびテストされ、私のソリューションの一部になりました。そして、それも非常に高速です。
問題は、ノードに親ポインターがある場合は本当に本当に簡単になり、さらに「出発したばかりの」ノードへの親のリンクをヌルにすることができるためです。
繰り返しのポストオーダー削除の擬似コードは次のとおりです。
Node current = root;
while (current)
{
if (current.left) current = current.left; // Dive down left
else if (current.right) current = current.right; // Dive down right
else
{
// Node "current" is a leaf, i.e. no left or right child
Node parent = current.parent; // assuming root.parent == null
if (parent)
{
// Null out the parent's link to the just departing node
if (parent.left == current) parent.left = null;
else parent.right = null;
}
delete current;
current = parent;
}
}
root = null;
複雑なコレクションをコーディングするためのより理論的なアプローチ（実際には自己均衡の赤黒木である私のバイナリツリーなど）に興味がある場合は、次のリンクをチェックしてください。
http://opendatastructures.org/versions/edition-0.1e/ods-Java/6_2_BinarySearchTree_Unbala.htmlhttp://opendatastructures.org/versions/edition-0.1e/ods- Java/9_2_RedBlackTree_Simulated_.htmlhttps://www.cs.auckland.ac.nz/software/AlgAnim/red_black.html
ハッピーコーディング:-)
ソーレン・フォグ http://iprotus.eu/
再帰なしで後順走査を実行する2つの方法：
1。バックトラッキングに訪問済みノードの1つのハッシュセットと1つのスタックを使用する：
private void postOrderWithoutRecursion(TreeNode root) {
if (root == null || root.left == null && root.right == null) {
return;
}
Stack<TreeNode> stack = new Stack<>();
Set<TreeNode> visited = new HashSet<>();
while (!stack.empty() || root != null) {
if (root != null) {
stack.Push(root);
visited.add(root);
root = root.left;
} else {
root = stack.peek();
if (root.right == null || visited.contains(root.right)) {
System.out.print(root.val+" ");
stack.pop();
root = null;
} else {
root = root.right;
}
}
}
}
時間の複雑さ：O（n）
スペースの複雑さ：O（2n）
2。ツリー変更方法の使用：
private void postOrderWithoutRecursionAlteringTree(TreeNode root) {
if (root == null || root.left == null && root.right == null) {
return;
}
Stack<TreeNode> stack = new Stack<>();
while (!stack.empty() || root != null) {
if (root != null) {
stack.Push(root);
root = root.left;
} else {
root = stack.peek();
if (root.right == null) {
System.out.print(root.val+" ");
stack.pop();
root = null;
} else {
TreeNode temp = root.right;
root.right = null;
root = temp;
}
}
}
}
時間の複雑さ：O（n）
スペースの複雑さ：O（n）
TreeNodeクラス：
public class TreeNode {
public int val;
public TreeNode left;
public TreeNode right;
public TreeNode(int x) {
val = x;
}
}
したがって、1つのスタックを使用して、ポストオーダートラバーサルを実行できます。
private void PostOrderTraversal(Node pos) {
Stack<Node> stack = new Stack<Node>();
do {
if (pos==null && (pos=stack.peek().right)==null) {
for (visit(stack.peek()); stack.pop()==(stack.isEmpty()?null:stack.peek().right); visit(stack.peek())) {}
} else if(pos!=null) {
stack.Push(pos);
pos=pos.left;
}
} while (!stack.isEmpty());
}
ここで、参照用にc＃（.net）のさまざまなバージョンを貼り付けます：（参照する可能性のある順序の反復走査については、 再帰を使用せずに順序走査を理解してください ）
- wiki（ http://en.wikipedia.org/wiki/Post-order%5Ftraversal#Implementations ）（エレガント）
- 単一スタックの別のバージョン（＃1および＃2：基本的に、ポストオーダートラバースでは、実際のノードにアクセスする前に正しい子ノードにアクセスするという事実を使用します。したがって、スタックトップの右の子が実際にアクセスされた最後のポストオーダートラバーサルノード-詳細については、以下のコードスニペットにコメントを追加しました）
- 2スタックバージョンの使用（参照： http://www.geeksforgeeks.org/iterative-postorder-traversal/ ）（簡単：基本的に、ポストオーダートラバーサルリバースは、単純なTweakによるプレオーダートラバーサルにすぎません最初に右ノードが訪問され、次に左ノードが訪問されます）
- ビジターフラグの使用（簡単）
- 単体テスト
〜
public string PostOrderIterative_WikiVersion()
{
List<int> nodes = new List<int>();
if (null != this._root)
{
BinaryTreeNode lastPostOrderTraversalNode = null;
BinaryTreeNode iterativeNode = this._root;
Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
while ((stack.Count > 0)//stack is not empty
|| (iterativeNode != null))
{
if (iterativeNode != null)
{
stack.Push(iterativeNode);
iterativeNode = iterativeNode.Left;
}
else
{
var stackTop = stack.Peek();
if((stackTop.Right != null)
&& (stackTop.Right != lastPostOrderTraversalNode))
{
//i.e. last traversal node is not right element, so right sub tree is not
//yet, traversed. so we need to start iterating over right tree
//(note left tree is by default traversed by above case)
iterativeNode = stackTop.Right;
}
else
{
//if either the iterative node is child node (right and left are null)
//or, stackTop's right element is nothing but the last traversal node
//(i.e; the element can be popped as the right sub tree have been traversed)
var top = stack.Pop();
Debug.Assert(top == stackTop);
nodes.Add(top.Element);
lastPostOrderTraversalNode = top;
}
}
}
}
return this.ListToString(nodes);
}
ここに1つのスタック（私のバージョン）でのポストオーダートラバーサルがあります
public string PostOrderIterative()
{
List<int> nodes = new List<int>();
if (null != this._root)
{
BinaryTreeNode lastPostOrderTraversalNode = null;
BinaryTreeNode iterativeNode = null;
Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
stack.Push(this._root);
while(stack.Count > 0)
{
iterativeNode = stack.Pop();
if ((iterativeNode.Left == null)
&& (iterativeNode.Right == null))
{
nodes.Add(iterativeNode.Element);
lastPostOrderTraversalNode = iterativeNode;
//make sure the stack is not empty as we need to peek at the top
//for ex, a tree with just root node doesn't have to enter loop
//and also node Peek() will throw invalidoperationexception
//if it is performed if the stack is empty
//so, it handles both of them.
while(stack.Count > 0)
{
var stackTop = stack.Peek();
bool removeTop = false;
if ((stackTop.Right != null) &&
//i.e. last post order traversal node is nothing but right node of
//stacktop. so, all the elements in the right subtree have been visted
//So, we can pop the top element
(stackTop.Right == lastPostOrderTraversalNode))
{
//in other words, we can pop the top if whole right subtree is
//traversed. i.e. last traversal node should be the right node
//as the right node will be traverse once all the subtrees of
//right node has been traversed
removeTop = true;
}
else if(
//right subtree is null
(stackTop.Right == null)
&& (stackTop.Left != null)
//last traversal node is nothing but the root of left sub tree node
&& (stackTop.Left == lastPostOrderTraversalNode))
{
//in other words, we can pop the top of stack if right subtree is null,
//and whole left subtree has been traversed
removeTop = true;
}
else
{
break;
}
if(removeTop)
{
var top = stack.Pop();
Debug.Assert(stackTop == top);
lastPostOrderTraversalNode = top;
nodes.Add(top.Element);
}
}
}
else
{
stack.Push(iterativeNode);
if(iterativeNode.Right != null)
{
stack.Push(iterativeNode.Right);
}
if(iterativeNode.Left != null)
{
stack.Push(iterativeNode.Left);
}
}
}
}
return this.ListToString(nodes);
}
2つのスタックを使用する
public string PostOrderIterative_TwoStacksVersion()
{
List<int> nodes = new List<int>();
if (null != this._root)
{
Stack<BinaryTreeNode> postOrderStack = new Stack<BinaryTreeNode>();
Stack<BinaryTreeNode> rightLeftPreOrderStack = new Stack<BinaryTreeNode>();
rightLeftPreOrderStack.Push(this._root);
while(rightLeftPreOrderStack.Count > 0)
{
var top = rightLeftPreOrderStack.Pop();
postOrderStack.Push(top);
if(top.Left != null)
{
rightLeftPreOrderStack.Push(top.Left);
}
if(top.Right != null)
{
rightLeftPreOrderStack.Push(top.Right);
}
}
while(postOrderStack.Count > 0)
{
var top = postOrderStack.Pop();
nodes.Add(top.Element);
}
}
return this.ListToString(nodes);
}
C＃（.net）の訪問済みフラグ付き：
public string PostOrderIterative()
{
List<int> nodes = new List<int>();
if (null != this._root)
{
BinaryTreeNode iterativeNode = null;
Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
stack.Push(this._root);
while(stack.Count > 0)
{
iterativeNode = stack.Pop();
if(iterativeNode.visted)
{
//reset the flag, for further traversals
iterativeNode.visted = false;
nodes.Add(iterativeNode.Element);
}
else
{
iterativeNode.visted = true;
stack.Push(iterativeNode);
if(iterativeNode.Right != null)
{
stack.Push(iterativeNode.Right);
}
if(iterativeNode.Left != null)
{
stack.Push(iterativeNode.Left);
}
}
}
}
return this.ListToString(nodes);
}
定義：
class BinaryTreeNode
{
public int Element;
public BinaryTreeNode Left;
public BinaryTreeNode Right;
public bool visted;
}
string ListToString(List<int> list)
{
string s = string.Join(", ", list);
return s;
}
単体テスト
[TestMethod]
public void PostOrderTests()
{
int[] a = { 13, 2, 18, 1, 5, 17, 20, 3, 6, 16, 21, 4, 14, 15, 25, 22, 24 };
BinarySearchTree bst = new BinarySearchTree();
foreach (int e in a)
{
string s1 = bst.PostOrderRecursive();
string s2 = bst.PostOrderIterativeWithVistedFlag();
string s3 = bst.PostOrderIterative();
string s4 = bst.PostOrderIterative_WikiVersion();
string s5 = bst.PostOrderIterative_TwoStacksVersion();
Assert.AreEqual(s1, s2);
Assert.AreEqual(s2, s3);
Assert.AreEqual(s3, s4);
Assert.AreEqual(s4, s5);
bst.Add(e);
bst.Delete(e);
bst.Add(e);
s1 = bst.PostOrderRecursive();
s2 = bst.PostOrderIterativeWithVistedFlag();
s3 = bst.PostOrderIterative();
s4 = bst.PostOrderIterative_WikiVersion();
s5 = bst.PostOrderIterative_TwoStacksVersion();
Assert.AreEqual(s1, s2);
Assert.AreEqual(s2, s3);
Assert.AreEqual(s3, s4);
Assert.AreEqual(s4, s5);
}
Debug.WriteLine(string.Format("PostOrderIterative: {0}", bst.PostOrderIterative()));
Debug.WriteLine(string.Format("PostOrderIterative_WikiVersion: {0}", bst.PostOrderIterative_WikiVersion()));
Debug.WriteLine(string.Format("PostOrderIterative_TwoStacksVersion: {0}", bst.PostOrderIterative_TwoStacksVersion()));
Debug.WriteLine(string.Format("PostOrderIterativeWithVistedFlag: {0}", bst.PostOrderIterativeWithVistedFlag()));
Debug.WriteLine(string.Format("PostOrderRecursive: {0}", bst.PostOrderRecursive()));
}
最も簡単な解決策は、最良の答えではないように見えるかもしれませんが、理解は簡単です。そして、あなたは解決策を理解しているなら、あなたはそれを修正して可能な限り最高の解決策を作ることができると信じています
// 2つのスタックを使用
public List<Integer> postorderTraversal(TreeNode root){
Stack<TreeNode> st=new Stack<>();
Stack<TreeNode> st2=new Stack<>();
ArrayList<Integer> al = new ArrayList<Integer>();
if(root==null)
return al;
st.Push(root); //Push the root to 1st stack
while(!st.isEmpty())
{
TreeNode curr=st.pop();
st2.Push(curr);
if(curr.left!=null)
st.Push(curr.left);
if(curr.right!=null)
st.Push(curr.right);
}
while(!st2.isEmpty())
al.add(st2.pop().val);
//this ArrayList contains the postorder traversal
return al;
}
void postorder_stack(Node * root){
stack ms;
ms.top = -1;
if(root == NULL) return ;
Node * temp ;
Push(&ms,root);
Node * prev = NULL;
while(!is_empty(ms)){
temp = peek(ms);
/* case 1. We are nmoving down the tree. */
if(prev == NULL || prev->left == temp || prev->right == temp){
if(temp->left)
Push(&ms,temp->left);
else if(temp->right)
Push(&ms,temp->right);
else {
/* If node is leaf node */
printf("%d ", temp->value);
pop(&ms);
}
}
/* case 2. We are moving up the tree from left child */
if(temp->left == prev){
if(temp->right)
Push(&ms,temp->right);
else
printf("%d ", temp->value);
}
/* case 3. We are moving up the tree from right child */
if(temp->right == prev){
printf("%d ", temp->value);
pop(&ms);
}
prev = temp;
}
}
2つのスタックを使用したJavaの実装
public static <T> List<T> iPostOrder(BinaryTreeNode<T> root) {
if (root == null) {
return Collections.emptyList();
}
List<T> result = new ArrayList<T>();
Deque<BinaryTreeNode<T>> firstLevel = new LinkedList<BinaryTreeNode<T>>();
Deque<BinaryTreeNode<T>> secondLevel = new LinkedList<BinaryTreeNode<T>>();
firstLevel.Push(root);
while (!firstLevel.isEmpty()) {
BinaryTreeNode<T> node = firstLevel.pop();
secondLevel.Push(node);
if (node.hasLeftChild()) {
firstLevel.Push(node.getLeft());
}
if (node.hasRightChild()) {
firstLevel.Push(node.getRight());
}
}
while (!secondLevel.isEmpty()) {
result.add(secondLevel.pop().getData());
}
return result;
}
これがユニットテストです
@Test
public void iterativePostOrderTest() {
BinaryTreeNode<Integer> bst = BinaryTreeUtil.<Integer>fromInAndPostOrder(new Integer[]{4,2,5,1,6,3,7}, new Integer[]{4,5,2,6,7,3,1});
assertThat(BinaryTreeUtil.iPostOrder(bst).toArray(new Integer[0]), equalTo(new Integer[]{4,5,2,6,7,3,1}));
}
1スタックでフラグなしのPython：
def postorderTraversal(self, root):
ret = []
if not root:
return ret
stack = [root]
current = None
while stack:
previous = current
current = stack.pop()
if previous and ((previous is current) or (previous is current.left) or (previous is current.right)):
ret.append(current.val)
else:
stack.append(current)
if current.right:
stack.append(current.right)
if current.left:
stack.append(current.left)
return ret
そして、トラバーサルも機能するように、同様のステートメントを使用する方が良い
def inorderTraversal(self, root):
ret = []
if not root:
return ret
stack = [root]
current = None
while stack:
previous = current
current = stack.pop()
if None == previous or previous.left is current or previous.right is current:
if current.right:
stack.append(current.right)
stack.append(current)
if current.left:
stack.append(current.left)
else:
ret.append(current.val)
return ret
import Java.util.Stack;
class Practice
{
public static void main(String arr[])
{
Practice prc = new Practice();
TreeNode node1 = (prc).new TreeNode(1);
TreeNode node2 = (prc).new TreeNode(2);
TreeNode node3 = (prc).new TreeNode(3);
TreeNode node4 = (prc).new TreeNode(4);
TreeNode node5 = (prc).new TreeNode(5);
TreeNode node6 = (prc).new TreeNode(6);
TreeNode node7 = (prc).new TreeNode(7);
node1.left = node2;
node1.right = node3;
node2.left = node4;
node2.right = node5;
node3.left = node6;
node3.right = node7;
postOrderIteratively(node1);
}
public static void postOrderIteratively(TreeNode root)
{
Stack<Entry> stack = new Stack<Entry>();
Practice prc = new Practice();
stack.Push((prc).new Entry(root, false));
while (!stack.isEmpty())
{
Entry entry = stack.pop();
TreeNode node = entry.node;
if (entry.flag == false)
{
if (node.right == null && node.left == null)
{
System.out.println(node.data);
} else
{
stack.Push((prc).new Entry(node, true));
if (node.right != null)
{
stack.Push((prc).new Entry(node.right, false));
}
if (node.left != null)
{
stack.Push((prc).new Entry(node.left, false));
}
}
} else
{
System.out.println(node.data);
}
}
}
class TreeNode
{
int data;
int leafCount;
TreeNode left;
TreeNode right;
public TreeNode(int data)
{
this.data = data;
}
public int getLeafCount()
{
return leafCount;
}
public void setLeafCount(int leafCount)
{
this.leafCount = leafCount;
}
public TreeNode getLeft()
{
return left;
}
public void setLeft(TreeNode left)
{
this.left = left;
}
public TreeNode getRight()
{
return right;
}
public void setRight(TreeNode right)
{
this.right = right;
}
@Override
public String toString()
{
return "" + this.data;
}
}
class Entry
{
Entry(TreeNode node, boolean flag)
{
this.node = node;
this.flag = flag;
}
TreeNode node;
boolean flag;
@Override
public String toString()
{
return node.toString();
}
}
}
/**
* This code will ensure holding of chain(links) of nodes from the root to till the level of the tree.
* The number of extra nodes in the memory (other than tree) is height of the tree.
* I haven't used Java stack instead used this ParentChain.
* This parent chain is the link for any node from the top(root node) to till its immediate parent.
* This code will not require any altering of existing BinaryTree (NO flag/parent on all the nodes).
*
* while visiting the Node 11; ParentChain will be holding the nodes 9 -> 8 -> 7 -> 1 where (-> is parent)
*
* 1
/ \
/ \
/ \
/ \
/ \
/ \
/ \
/ \
2 7
/ \ /
/ \ /
/ \ /
/ \ /
3 6 8
/ \ /
/ \ /
4 5 9
/ \
10 11
*
* @author ksugumar
*
*/
public class InOrderTraversalIterative {
public static void main(String[] args) {
BTNode<String> rt;
String[] dataArray = {"1","2","3","4",null,null,"5",null,null,"6",null,null,"7","8","9","10",null,null,"11",null,null,null,null};
rt = BTNode.buildBTWithPreOrder(dataArray, new Counter(0));
BTDisplay.printTreeNode(rt);
inOrderTravesal(rt);
}
public static void postOrderTravesal(BTNode<String> root) {
ParentChain rootChain = new ParentChain(root);
rootChain.Parent = new ParentChain(null);
while (root != null) {
//Going back to parent
if(rootChain.leftVisited && rootChain.rightVisited) {
System.out.println(root.data); //Visit the node.
ParentChain parentChain = rootChain.Parent;
rootChain.Parent = null; //Avoid the leak
rootChain = parentChain;
root = rootChain.root;
continue;
}
//Traverse Left
if(!rootChain.leftVisited) {
rootChain.leftVisited = true;
if (root.left != null) {
ParentChain local = new ParentChain(root.left); //It is better to use pool to reuse the instances.
local.Parent = rootChain;
rootChain = local;
root = root.left;
continue;
}
}
//Traverse RIGHT
if(!rootChain.rightVisited) {
rootChain.rightVisited = true;
if (root.right != null) {
ParentChain local = new ParentChain(root.right); //It is better to use pool to reuse the instances.
local.Parent = rootChain;
rootChain = local;
root = root.right;
continue;
}
}
}
}
class ParentChain {
BTNode<String> root;
ParentChain Parent;
boolean leftVisited = false;
boolean rightVisited = false;
public ParentChain(BTNode<String> node) {
this.root = node;
}
@Override
public String toString() {
return root.toString();
}
}
void display_without_recursion(struct btree **b)
{
deque< struct btree* > dtree;
if(*b)
dtree.Push_back(*b);
while(!dtree.empty() )
{
struct btree* t = dtree.front();
cout << t->nodedata << " " ;
dtree.pop_front();
if(t->right)
dtree.Push_front(t->right);
if(t->left)
dtree.Push_front(t->left);
}
cout << endl;
}
深さ優先、ポストオーダー、非再帰的、スタックなし
親がいる場合：
node_t
{
left,
right
parent
}
traverse(node_t rootNode)
{
bool backthreading = false
node_t node = rootNode
while(node <> 0)
if (node->left <> 0) and backthreading = false then
node = node->left
continue
endif
>>> process node here <<<
if node->right <> 0 then
lNode = node->right
backthreading = false
else
node = node->parent
backthreading = true
endif
endwhile