Tree Traversal (preOrder, inOrder, postOrder, levelOrder, zigzagOrder)

  1 class TreeNode{

  2     char data;

  3     TreeNode left;

  4     TreeNode right;

  5     static int leaf;

  6     static boolean flag=true;

  7     TreeNode (char c){

  8         data = c;

  9     }

 10     TreeNode (TreeNode n){

 11         data = n.data;

 12         left = n.left;

 13         right = n.right;

 14     }

 15     

 16     public static void visit(TreeNode n){

 17         if(n == null)

 18             System.out.print("");

 19         else{

 20             if(flag){

 21                 System.out.print(n.data);

 22                 flag = false;

 23             }else{

 24                 System.out.print(" " + n.data);

 25             }

 26         }

 27         if(n.left == null && n.right == null) {

 28             leaf++;

 29         }

 30     }

 31     

 32     public static void preOrder(TreeNode root){

 33         if(root == null) return;

 34         visit(root);

 35         preOrder(root.left);

 36         preOrder(root.right);

 37     }

 38     

 39 //    public static void preOrder2(TreeNode root){

 40 //        if(root == null) return;

 41 //        Stack<TreeNode> stack = new Stack<TreeNode>();

 42 //        stack.add(root);

 43 //        while(!stack.isEmpty()){

 44 //            TreeNode top = stack.pop();

 45 //            visit(top);

 46 //            if(top.right != null) stack.add(top.right);

 47 //            if(top.left != null) stack.add(top.left);

 48 //        }

 49 //    }

 50     

 51     public static void preOrder2(TreeNode root){

 52         if(root == null) return;

 53         Stack<TreeNode> stack = new Stack<TreeNode>();

 54         while(!stack.isEmpty() || root != null){

 55             if(root != null){

 56                 stack.push(root);

 57                 visit(root);

 58                 root = root.left;

 59             }else{

 60                 root = stack.pop();

 61                 root = root.right;

 62             }    

 63         }

 64     }

 65     public static void inOrder(TreeNode root){

 66         if(root == null) return;

 67         inOrder(root.left);

 68         visit(root);

 69         inOrder(root.right);

 70     }

 71     

 72     public static void inOrder2(TreeNode root){

 73         if(root == null) return;

 74         Stack<TreeNode> stack = new Stack<TreeNode>();

 75         while(!stack.empty() || root != null){

 76             if(root != null){

 77                 stack.push(root);

 78                 root = root.left;

 79             }else{

 80                 //reached leftMost

 81                 root = stack.pop();

 82                 visit(root);

 83                 root = root.right;

 84             }

 85         }

 86     }

 87     

 88     public static void postOrder(TreeNode root){

 89         if(root == null) return;

 90         postOrder(root.left);

 91         postOrder(root.right);

 92         visit(root);

 93     }

 94     

 95     public static void levelOrder(TreeNode root){

 96         if(root == null) return;

 97         LinkedList<TreeNode> q = new LinkedList<TreeNode>();

 98         q.add(root);

 99         while(!q.isEmpty()){

100             TreeNode head = q.removeFirst();

101             visit(head);

102             if(head.left != null) q.add(head.left);

103             if(head.right != null) q.add(head.right);

104         }

105     }

106     

107     public static void zigzagOrder(TreeNode root){

108         LinkedList<TreeNode> currentLevel = new LinkedList<TreeNode>();

109         int level = 0;

110         if(root != null) 

111             currentLevel.add(root);

112         while(!currentLevel.isEmpty()){

113             LinkedList<TreeNode> nextLevel = new LinkedList<TreeNode>();

114             ArrayList<TreeNode> list = new ArrayList<TreeNode>();

115             for(TreeNode node : currentLevel){

116                 list.add(node);

117                 if(node.left != null)

118                     nextLevel.add(node.left);

119                 if(node.right != null)

120                     nextLevel.add(node.right);

121             }

122             if(level%2 == 1)

123                 Collections.reverse(list);

124             for(int i = 0; i < list.size(); i++)

125                 visit(list.get(i));

126             currentLevel = nextLevel;

127             level++;

128         }

129         

130     }

131     

132 }