Skip to content

Commit 5f8d8ee

Browse files
UdayaKrishnanMKrishnan MDenizAltunkapan
authored
Added Pretty Display method and BSTRecursiveGenericTests.java (#6621)
* added binarysearchtree * added binarysearchtree * updated * updated the test values * updated build issues * updated * updated * updated * updated * updated * updated * updated * added pretty display method * added pretty display method * updated pretty Display and added BSTRecursiveGenericTest.java * updated pretty Display and added BSTRecursiveGenericTest.java * updated pretty Display and added BSTRecursiveGenericTest.java * updated pretty Display and added BSTRecursiveGenericTest.java * updated pretty Display and added BSTRecursiveGenericTest.java * added pretty display method * updated pretty Display and added BSTRecursiveGenericTest.java * updated pretty Display and added BSTRecursiveGenericTest.java * updated pretty Display and added BSTRecursiveGenericTest.java --------- Co-authored-by: Krishnan M <[email protected]> Co-authored-by: Deniz Altunkapan <[email protected]>
1 parent 959ced9 commit 5f8d8ee

File tree

2 files changed

+210
-3
lines changed

2 files changed

+210
-3
lines changed

‎src/main/java/com/thealgorithms/datastructures/trees/BSTRecursiveGeneric.java‎

Lines changed: 41 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@
1313
* </p>
1414
*
1515
* @author [Madhur Panwar](<a href="https://github.com/mdrpanwar">git-Madhur Panwar</a>)
16+
* @author [Udaya Krishnan M](<a href="https://github.com/UdayaKrishnanM/">git-Udaya Krishnan M</a>) {added prettyDisplay() method}
1617
*/
1718
public class BSTRecursiveGeneric<T extends Comparable<T>> {
1819

@@ -28,6 +29,29 @@ public BSTRecursiveGeneric() {
2829
root = null;
2930
}
3031

32+
/**
33+
* Displays the tree is a structed format
34+
*/
35+
public void prettyDisplay() {
36+
prettyDisplay(root, 0);
37+
}
38+
39+
private void prettyDisplay(Node<T> node, int level) {
40+
if (node == null) {
41+
return;
42+
}
43+
prettyDisplay(node.right, level + 1);
44+
if (level != 0) {
45+
for (int i = 0; i < level - 1; i++) {
46+
System.out.print("|\t");
47+
}
48+
System.out.println("|---->" + node.data);
49+
} else {
50+
System.out.println(node.data);
51+
}
52+
prettyDisplay(node.left, level + 1);
53+
}
54+
3155
/**
3256
* main function for testing
3357
*/
@@ -38,7 +62,12 @@ public static void main(String[] args) {
3862

3963
integerTree.add(5);
4064
integerTree.add(10);
41-
integerTree.add(9);
65+
integerTree.add(-9);
66+
integerTree.add(4);
67+
integerTree.add(3);
68+
integerTree.add(1);
69+
System.out.println("Pretty Display of current tree is:");
70+
integerTree.prettyDisplay();
4271
assert !integerTree.find(4)
4372
: "4 is not yet present in BST";
4473
assert integerTree.find(10)
@@ -54,16 +83,21 @@ public static void main(String[] args) {
5483
assert integerTree.find(70)
5584
: "70 was inserted but not found";
5685
/*
57-
Will print in following order
58-
5 10 20 70
86+
Will print in following order
87+
5 10 20 70
5988
*/
89+
System.out.println("Pretty Display of current tree is:");
90+
integerTree.prettyDisplay();
6091
integerTree.inorder();
92+
System.out.println("Pretty Display of current tree is:");
93+
integerTree.prettyDisplay();
6194
System.out.println();
6295
System.out.println("Testing for string data...");
6396
// String
6497
BSTRecursiveGeneric<String> stringTree = new BSTRecursiveGeneric<String>();
6598

6699
stringTree.add("banana");
100+
stringTree.add("apple");
67101
stringTree.add("pineapple");
68102
stringTree.add("date");
69103
assert !stringTree.find("girl")
@@ -80,11 +114,15 @@ public static void main(String[] args) {
80114
stringTree.add("hills");
81115
assert stringTree.find("hills")
82116
: "hills was inserted but not found";
117+
System.out.println("Pretty Display of current tree is:");
118+
stringTree.prettyDisplay();
83119
/*
84120
Will print in following order
85121
banana hills india pineapple
86122
*/
87123
stringTree.inorder();
124+
System.out.println("Pretty Display of current tree is:");
125+
stringTree.prettyDisplay();
88126
}
89127

90128
/**

‎src/test/java/com/thealgorithms/datastructures/trees/BSTRecursiveGenericTest.java‎

Lines changed: 169 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,169 @@
1+
package com.thealgorithms.datastructures.trees;
2+
3+
import static org.junit.jupiter.api.Assertions.assertEquals;
4+
import static org.junit.jupiter.api.Assertions.assertFalse;
5+
import static org.junit.jupiter.api.Assertions.assertTrue;
6+
7+
import java.util.List;
8+
import org.junit.jupiter.api.BeforeEach;
9+
import org.junit.jupiter.api.Test;
10+
11+
/**
12+
* Unit tests for BSTRecursiveGeneric class.
13+
* Covers insertion, deletion, search, traversal, sorting, and display.
14+
*
15+
* Author: Udaya Krishnan M
16+
* GitHub: https://github.com/UdayaKrishnanM/
17+
*/
18+
class BSTRecursiveGenericTest {
19+
20+
private BSTRecursiveGeneric<Integer> intTree;
21+
private BSTRecursiveGeneric<String> stringTree;
22+
23+
/**
24+
* Initializes test trees before each test.
25+
*/
26+
@BeforeEach
27+
void setUp() {
28+
intTree = new BSTRecursiveGeneric<>();
29+
stringTree = new BSTRecursiveGeneric<>();
30+
}
31+
32+
/**
33+
* Tests insertion and search of integer values.
34+
*/
35+
@Test
36+
void testAddAndFindInteger() {
37+
intTree.add(10);
38+
intTree.add(5);
39+
intTree.add(15);
40+
assertTrue(intTree.find(10));
41+
assertTrue(intTree.find(5));
42+
assertTrue(intTree.find(15));
43+
assertFalse(intTree.find(20));
44+
}
45+
46+
/**
47+
* Tests insertion and search of string values.
48+
*/
49+
@Test
50+
void testAddAndFindString() {
51+
stringTree.add("apple");
52+
stringTree.add("banana");
53+
stringTree.add("cherry");
54+
assertTrue(stringTree.find("banana"));
55+
assertFalse(stringTree.find("date"));
56+
}
57+
58+
/**
59+
* Tests deletion of existing and non-existing elements.
60+
*/
61+
@Test
62+
void testRemoveElements() {
63+
intTree.add(10);
64+
intTree.add(5);
65+
intTree.add(15);
66+
assertTrue(intTree.find(5));
67+
intTree.remove(5);
68+
assertFalse(intTree.find(5));
69+
intTree.remove(100); // non-existent
70+
assertFalse(intTree.find(100));
71+
}
72+
73+
/**
74+
* Tests inorder traversal output.
75+
*/
76+
@Test
77+
void testInorderTraversal() {
78+
intTree.add(20);
79+
intTree.add(10);
80+
intTree.add(30);
81+
intTree.inorder(); // visually verify output
82+
assertTrue(true);
83+
}
84+
85+
/**
86+
* Tests preorder traversal output.
87+
*/
88+
@Test
89+
void testPreorderTraversal() {
90+
intTree.add(20);
91+
intTree.add(10);
92+
intTree.add(30);
93+
intTree.preorder(); // visually verify output
94+
assertTrue(true);
95+
}
96+
97+
/**
98+
* Tests postorder traversal output.
99+
*/
100+
@Test
101+
void testPostorderTraversal() {
102+
intTree.add(20);
103+
intTree.add(10);
104+
intTree.add(30);
105+
intTree.postorder(); // visually verify output
106+
assertTrue(true);
107+
}
108+
109+
/**
110+
* Tests inorderSort returns sorted list.
111+
*/
112+
@Test
113+
void testInorderSort() {
114+
intTree.add(30);
115+
intTree.add(10);
116+
intTree.add(20);
117+
List<Integer> sorted = intTree.inorderSort();
118+
assertEquals(List.of(10, 20, 30), sorted);
119+
}
120+
121+
/**
122+
* Tests prettyDisplay method for visual tree structure.
123+
*/
124+
@Test
125+
void testPrettyDisplay() {
126+
intTree.add(50);
127+
intTree.add(30);
128+
intTree.add(70);
129+
intTree.add(20);
130+
intTree.add(40);
131+
intTree.add(60);
132+
intTree.add(80);
133+
intTree.prettyDisplay(); // visually verify output
134+
assertTrue(true);
135+
}
136+
137+
/**
138+
* Tests edge case: empty tree.
139+
*/
140+
@Test
141+
void testEmptyTree() {
142+
assertFalse(intTree.find(1));
143+
List<Integer> sorted = intTree.inorderSort();
144+
assertTrue(sorted.isEmpty());
145+
}
146+
147+
/**
148+
* Tests edge case: single node tree.
149+
*/
150+
@Test
151+
void testSingleNodeTree() {
152+
intTree.add(42);
153+
assertTrue(intTree.find(42));
154+
intTree.remove(42);
155+
assertFalse(intTree.find(42));
156+
}
157+
158+
/**
159+
* Tests duplicate insertions.
160+
*/
161+
@Test
162+
void testDuplicateInsertions() {
163+
intTree.add(10);
164+
intTree.add(10);
165+
intTree.add(10);
166+
List<Integer> sorted = intTree.inorderSort();
167+
assertEquals(List.of(10), sorted); // assuming duplicates are ignored
168+
}
169+
}

0 commit comments

Comments
 (0)