Skip to content

Commit 2eeb370

Browse files
GauravWalia19GauravWalia19
committed
added binary trees traversals & complexity in java
1 parent f4068ca commit 2eeb370

11 files changed

+521
-97
lines changed

‎Java/Data-Structures/TREES/BINARY-TREE/BinaryTreeNode.java

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
public class BinaryTreeNode
2+
{
3+
public int data;
4+
public BinaryTreeNode left;
5+
public BinaryTreeNode right;
6+
7+
public BinaryTreeNode(int data)
8+
{
9+
this.data=data;
10+
left=null;
11+
right=null;
12+
}
13+
public int getData()
14+
{
15+
return data;
16+
}
17+
public void setData(int data)
18+
{
19+
this.data=data;
20+
}
21+
public BinaryTreeNode getLeft()
22+
{
23+
return left;
24+
}
25+
public void setLeft(BinaryTreeNode left)
26+
{
27+
this.left = left;
28+
}
29+
public BinaryTreeNode getRight()
30+
{
31+
return right;
32+
}
33+
public void setRight(BinaryTreeNode right)
34+
{
35+
this.right=right;
36+
}
37+
}

‎Java/Data-Structures/TREES/BINARY-TREE/Inorder.java

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
public class Inorder
2+
{
3+
public static void main(String[] args)
4+
{
5+
BinaryTreeNode ROOT = null;
6+
BinaryTreeNode a = new BinaryTreeNode(1);
7+
BinaryTreeNode b = new BinaryTreeNode(2);
8+
BinaryTreeNode c = new BinaryTreeNode(3);
9+
BinaryTreeNode d = new BinaryTreeNode(4);
10+
BinaryTreeNode e = new BinaryTreeNode(5);
11+
BinaryTreeNode f = new BinaryTreeNode(6);
12+
BinaryTreeNode g = new BinaryTreeNode(7);
13+
14+
ROOT=a;
15+
ROOT.setLeft(b);
16+
ROOT.setRight(c);
17+
b.setLeft(d);
18+
b.setRight(e);
19+
c.setLeft(f);
20+
c.setRight(g);
21+
22+
inorder(ROOT);
23+
}
24+
public static void inorder(BinaryTreeNode ROOT)
25+
{
26+
if(ROOT==null)
27+
{
28+
return;
29+
}
30+
inorder(ROOT.left);
31+
System.out.print(ROOT.data+" ");
32+
inorder(ROOT.right);
33+
}
34+
}

‎Java/Data-Structures/TREES/BINARY-TREE/IterativeInorder.java

+54
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
import java.util.*;
2+
public class IterativeInorder
3+
{
4+
public static void main(String[] args) {
5+
BinaryTreeNode ROOT = null;
6+
BinaryTreeNode a = new BinaryTreeNode(1);
7+
BinaryTreeNode b = new BinaryTreeNode(2);
8+
BinaryTreeNode c = new BinaryTreeNode(3);
9+
BinaryTreeNode d = new BinaryTreeNode(4);
10+
BinaryTreeNode e = new BinaryTreeNode(5);
11+
BinaryTreeNode f = new BinaryTreeNode(6);
12+
BinaryTreeNode g = new BinaryTreeNode(7);
13+
14+
ROOT=a;
15+
ROOT.setLeft(b);
16+
ROOT.setRight(c);
17+
b.setLeft(d);
18+
b.setRight(e);
19+
c.setLeft(f);
20+
c.setRight(g);
21+
22+
inorder(ROOT);
23+
}
24+
25+
public static void inorder(BinaryTreeNode ROOT)
26+
{
27+
if(ROOT==null)
28+
{
29+
return;
30+
}
31+
Stack<BinaryTreeNode> S = new Stack<BinaryTreeNode>();
32+
boolean done=false;
33+
BinaryTreeNode current=ROOT;
34+
while(!done)
35+
{
36+
if(current!=null)
37+
{
38+
S.push(current);
39+
current=current.left;
40+
}
41+
else //if null value found
42+
{
43+
if(S.isEmpty())
44+
done=true;
45+
else
46+
{
47+
current = S.pop();
48+
System.out.print(current.data+" ");
49+
current=current.right;
50+
}
51+
}
52+
}
53+
}
54+
}

‎Java/Data-Structures/TREES/BINARY-TREE/IterativePostorder.java

+63
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,63 @@
1+
import java.util.*;
2+
public class IterativePostorder
3+
{
4+
public static void main(String[] args) {
5+
BinaryTreeNode ROOT = null;
6+
BinaryTreeNode a = new BinaryTreeNode(1);
7+
BinaryTreeNode b = new BinaryTreeNode(2);
8+
BinaryTreeNode c = new BinaryTreeNode(3);
9+
BinaryTreeNode d = new BinaryTreeNode(4);
10+
BinaryTreeNode e = new BinaryTreeNode(5);
11+
BinaryTreeNode f = new BinaryTreeNode(6);
12+
BinaryTreeNode g = new BinaryTreeNode(7);
13+
14+
ROOT=a;
15+
ROOT.setLeft(b);
16+
ROOT.setRight(c);
17+
b.setLeft(d);
18+
b.setRight(e);
19+
c.setLeft(f);
20+
c.setRight(g);
21+
22+
postorder(ROOT);
23+
}
24+
public static void postorder(BinaryTreeNode ROOT)
25+
{
26+
if(ROOT==null)
27+
{
28+
return;
29+
}
30+
Stack<BinaryTreeNode> S = new Stack<BinaryTreeNode>();
31+
S.push(ROOT);
32+
BinaryTreeNode prev=null;
33+
while(!S.isEmpty())
34+
{
35+
BinaryTreeNode current = S.peek();
36+
if(prev==null || prev.left==current || prev.right==current)
37+
{
38+
//traverse left then right
39+
if(current.left!=null)
40+
{
41+
S.push(current.left);
42+
}
43+
else if(current.right!=null)
44+
{
45+
S.push(current.right);
46+
}
47+
}
48+
else if(current.left==prev)
49+
{
50+
if(current.right!=null)
51+
{
52+
S.push(current.right);
53+
}
54+
}
55+
else
56+
{
57+
System.out.print(current.data+" ");
58+
S.pop();
59+
}
60+
prev=current;
61+
}
62+
}
63+
}

‎Java/Data-Structures/TREES/BINARY-TREE/IterativePreorder.java

+48
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
import java.util.*;
2+
public class IterativePreorder
3+
{
4+
public static void main(String[] args)
5+
{
6+
BinaryTreeNode ROOT = null;
7+
BinaryTreeNode a = new BinaryTreeNode(1);
8+
BinaryTreeNode b = new BinaryTreeNode(2);
9+
BinaryTreeNode c = new BinaryTreeNode(3);
10+
BinaryTreeNode d = new BinaryTreeNode(4);
11+
BinaryTreeNode e = new BinaryTreeNode(5);
12+
BinaryTreeNode f = new BinaryTreeNode(6);
13+
BinaryTreeNode g = new BinaryTreeNode(7);
14+
15+
ROOT=a;
16+
ROOT.setLeft(b);
17+
ROOT.setRight(c);
18+
b.setLeft(d);
19+
b.setRight(e);
20+
c.setLeft(f);
21+
c.setRight(g);
22+
23+
preorder(ROOT);
24+
}
25+
public static void preorder(BinaryTreeNode ROOT)
26+
{
27+
if(ROOT==null)
28+
{
29+
return;
30+
}
31+
Stack<BinaryTreeNode> s = new Stack<BinaryTreeNode>();
32+
s.push(ROOT);
33+
while(!s.empty())
34+
{
35+
BinaryTreeNode tmp= s.pop();
36+
System.out.print(tmp.data+" ");
37+
38+
if(tmp.right!=null)
39+
{
40+
s.push(tmp.right);
41+
}
42+
if(tmp.left!=null)
43+
{
44+
s.push(tmp.left);
45+
}
46+
}
47+
}
48+
}

‎Java/Data-Structures/TREES/BINARY-TREE/LevelOrder.java

+48
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
import java.util.*;
2+
public class LevelOrder
3+
{
4+
public static void main(String[] args) {
5+
BinaryTreeNode ROOT = null;
6+
BinaryTreeNode a = new BinaryTreeNode(1);
7+
BinaryTreeNode b = new BinaryTreeNode(2);
8+
BinaryTreeNode c = new BinaryTreeNode(3);
9+
BinaryTreeNode d = new BinaryTreeNode(4);
10+
BinaryTreeNode e = new BinaryTreeNode(5);
11+
BinaryTreeNode f = new BinaryTreeNode(6);
12+
BinaryTreeNode g = new BinaryTreeNode(7);
13+
14+
ROOT=a;
15+
ROOT.setLeft(b);
16+
ROOT.setRight(c);
17+
b.setLeft(d);
18+
b.setRight(e);
19+
c.setLeft(f);
20+
c.setRight(g);
21+
22+
levelorder(ROOT);
23+
}
24+
public static void levelorder(BinaryTreeNode ROOT)
25+
{
26+
if(ROOT==null)
27+
{
28+
return;
29+
}
30+
Queue<BinaryTreeNode> Q = new LinkedList<BinaryTreeNode>();
31+
BinaryTreeNode current=ROOT;
32+
33+
while(current!=null)
34+
{
35+
System.out.print(current.data +" ");
36+
if(current.left!=null)
37+
{
38+
Q.add(current.left);
39+
}
40+
if(current.right!=null)
41+
{
42+
Q.add(current.right);
43+
}
44+
45+
current=Q.poll();
46+
}
47+
}
48+
}

‎Java/Data-Structures/TREES/BINARY-TREE/Postorder.java

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
public class Postorder
2+
{
3+
public static void main(String[] args) {
4+
BinaryTreeNode ROOT = null;
5+
BinaryTreeNode a = new BinaryTreeNode(1);
6+
BinaryTreeNode b = new BinaryTreeNode(2);
7+
BinaryTreeNode c = new BinaryTreeNode(3);
8+
BinaryTreeNode d = new BinaryTreeNode(4);
9+
BinaryTreeNode e = new BinaryTreeNode(5);
10+
BinaryTreeNode f = new BinaryTreeNode(6);
11+
BinaryTreeNode g = new BinaryTreeNode(7);
12+
13+
ROOT=a;
14+
ROOT.setLeft(b);
15+
ROOT.setRight(c);
16+
b.setLeft(d);
17+
b.setRight(e);
18+
c.setLeft(f);
19+
c.setRight(g);
20+
21+
postorder(ROOT);
22+
}
23+
public static void postorder(BinaryTreeNode ROOT)
24+
{
25+
if(ROOT==null)
26+
{
27+
return;
28+
}
29+
postorder(ROOT.left);
30+
postorder(ROOT.right);
31+
System.out.print(ROOT.data+" ");
32+
}
33+
}

‎Java/Data-Structures/TREES/BINARY-TREE/Preorder.java

+34
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
public class Preorder
2+
{
3+
public static void main(String[] args)
4+
{
5+
BinaryTreeNode ROOT = null;
6+
BinaryTreeNode a = new BinaryTreeNode(1);
7+
BinaryTreeNode b = new BinaryTreeNode(2);
8+
BinaryTreeNode c = new BinaryTreeNode(3);
9+
BinaryTreeNode d = new BinaryTreeNode(4);
10+
BinaryTreeNode e = new BinaryTreeNode(5);
11+
BinaryTreeNode f = new BinaryTreeNode(6);
12+
BinaryTreeNode g = new BinaryTreeNode(7);
13+
14+
ROOT=a;
15+
ROOT.setLeft(b);
16+
ROOT.setRight(c);
17+
b.setLeft(d);
18+
b.setRight(e);
19+
c.setLeft(f);
20+
c.setRight(g);
21+
22+
preorder(ROOT);
23+
}
24+
public static void preorder(BinaryTreeNode ROOT)
25+
{
26+
if(ROOT==null)
27+
{
28+
return;
29+
}
30+
System.out.print(ROOT.getData()+" "); //root
31+
preorder(ROOT.getLeft()); //left
32+
preorder(ROOT.getRight()); //right
33+
}
34+
}

‎Java/README.md

+18
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,24 @@
4646

4747
#### TREES
4848

49+
##### BINARY TREES
50+
51+
* [Binary Tree Node Example](Data-Structures/TREES/BINARY-TREE/BinaryTreeNode.java)
52+
* Traversals
53+
* Depth First Search
54+
* IN ORDER
55+
* [ITERATIVE](Data-Structures/TREES/BINARY-TREE/IterativeInorder.java)
56+
* [RECURSIVE](Data-Structures/TREES/BINARY-TREE/Inorder.java)
57+
* PRE ORDER
58+
* [ITERATIVE](Data-Structures/TREES/BINARY-TREE/IterativePreorder.java)
59+
* [RECURSIVE](Data-Structures/TREES/BINARY-TREE/Preorder.java)
60+
* POST ORDER
61+
* [ITERATIVE](Data-Structures/TREES/BINARY-TREE/IterativePostorder.java)
62+
* [RECURSIVE](Data-Structures/TREES/BINARY-TREE/Postorder.java)
63+
* Breadth First Search
64+
* LEVEL ORDER
65+
* [ITERATIVE](Data-Structures/TREES/BINARY-TREE/LevelOrder.java)
66+
4967
### :rocket: DYNAMIC PROGRAMMING
5068

5169
### :rocket: MISC

0 commit comments

Comments
 (0)