Skip to content

Commit d0024b7

Browse files
amarmaurya-comamarmaurya-com
committed
Added AVL tree implementation with detailed comments
1 parent f3d7f0e commit d0024b7

File tree

4 files changed

+227
-56
lines changed

4 files changed

+227
-56
lines changed

‎src/main/java/com/thealgorithms/tree/AVL.java‎

Lines changed: 26 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -122,7 +122,9 @@ public List<Integer> postorderList() {
122122
*/
123123
private Node insertRecursive(Node node, int key) {
124124
// Step 1: Perform standard BST insert
125-
if (node == null) return new Node(key);
125+
if (node == null) {
126+
return new Node(key);
127+
}
126128

127129
if (key < node.key)
128130
node.left = insertRecursive(node.left, key);
@@ -245,8 +247,8 @@ private Node balanceNode(Node node) {
245247
int balance = getBalance(node);
246248

247249
// Case 1: Left Left (LL)
248-
if (balance > 1 && getBalance(node.left) >= 0)
249-
return rightRotate(node);
250+
if (balance > 1 && getBalance(node.left) >= 0) return rightRotate(node);
251+
250252

251253
// Case 2: Left Right (LR)
252254
if (balance > 1 && getBalance(node.left) < 0) {
@@ -255,8 +257,8 @@ private Node balanceNode(Node node) {
255257
}
256258

257259
// Case 3: Right Right (RR)
258-
if (balance < -1 && getBalance(node.right) <= 0)
259-
return leftRotate(node);
260+
if (balance < -1 && getBalance(node.right) <= 0) return leftRotate(node);
261+
260262

261263
// Case 4: Right Left (RL)
262264
if (balance < -1 && getBalance(node.right) > 0) {
@@ -287,42 +289,54 @@ private int getBalance(Node node) {
287289
/* ======================== TRAVERSALS ======================== */
288290

289291
private void printInorderRecursive(Node node) {
290-
if (node == null) return;
292+
if (node == null) {
293+
return;
294+
}
291295
printInorderRecursive(node.left);
292296
System.out.print(node.key + " ");
293297
printInorderRecursive(node.right);
294298
}
295299

296300
private void printPreorderRecursive(Node node) {
297-
if (node == null) return;
301+
if (node == null) {
302+
return;
303+
}
298304
System.out.print(node.key + " ");
299305
printPreorderRecursive(node.left);
300306
printPreorderRecursive(node.right);
301307
}
302308

303309
private void printPostorderRecursive(Node node) {
304-
if (node == null) return;
310+
if (node == null) {
311+
return;
312+
}
305313
printPostorderRecursive(node.left);
306314
printPostorderRecursive(node.right);
307315
System.out.print(node.key + " ");
308316
}
309317

310318
private void inorderToList(Node node, List<Integer> out) {
311-
if (node == null) return;
319+
if (node == null) {
320+
return;
321+
}
312322
inorderToList(node.left, out);
313323
out.add(node.key);
314324
inorderToList(node.right, out);
315325
}
316326

317327
private void preorderToList(Node node, List<Integer> out) {
318-
if (node == null) return;
328+
if (node == null) {
329+
return;
330+
}
319331
out.add(node.key);
320332
preorderToList(node.left, out);
321333
preorderToList(node.right, out);
322334
}
323335

324336
private void postorderToList(Node node, List<Integer> out) {
325-
if (node == null) return;
337+
if (node == null) {
338+
return;
339+
}
326340
postorderToList(node.left, out);
327341
postorderToList(node.right, out);
328342
out.add(node.key);
@@ -337,7 +351,7 @@ public static void main(String[] args) {
337351
for (int v : values) avl.insert(v);
338352

339353
// Display traversals
340-
avl.printInorder(); // should show sorted order
354+
avl.printInorder(); // should show sorted order
341355
avl.printPreorder();
342356
avl.printPostorder();
343357

‎src/main/java/com/thealgorithms/tree/BST.java‎

Lines changed: 59 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,7 @@ private static class Node {
2727

2828
// Root of the BST
2929
// the first of Node tree
30-
//0->
30+
// 0->
3131
private Node root;
3232

3333
/** Create an empty BST. */
@@ -196,10 +196,12 @@ public void printInorder() {
196196
}
197197

198198
private void printInorderRecursive(Node node) {
199-
if (node == null) return;
200-
printInorderRecursive(node.left); // left
201-
System.out.print(node.key + " "); // node
202-
printInorderRecursive(node.right); // right
199+
if (node == null) {
200+
return;
201+
}
202+
printInorderRecursive(node.left); // left
203+
System.out.print(node.key + " "); // node
204+
printInorderRecursive(node.right); // right
203205
}
204206

205207
/**
@@ -213,10 +215,12 @@ public void printPreorder() {
213215
}
214216

215217
private void printPreorderRecursive(Node node) {
216-
if (node == null) return;
217-
System.out.print(node.key + " "); // node
218-
printPreorderRecursive(node.left); // left
219-
printPreorderRecursive(node.right); // right
218+
if (node == null) {
219+
return;
220+
}
221+
System.out.print(node.key + " "); // node
222+
printPreorderRecursive(node.left); // left
223+
printPreorderRecursive(node.right); // right
220224
}
221225

222226
/**
@@ -230,20 +234,24 @@ public void printPostorder() {
230234
}
231235

232236
private void printPostorderRecursive(Node node) {
233-
if (node == null) return;
234-
printPostorderRecursive(node.left); // left
235-
printPostorderRecursive(node.right); // right
236-
System.out.print(node.key + " "); // node
237+
if (node == null) {
238+
return;
239+
}
240+
printPostorderRecursive(node.left); // left
241+
printPostorderRecursive(node.right); // right
242+
System.out.print(node.key + " "); // node
237243
}
238244

239-
public List<Integer> inorderList() {
245+
public List<Integer> inorderList() {
240246
List<Integer> result = new ArrayList<>();
241247
inorderToList(root, result);
242248
return result;
243249
}
244250

245251
private void inorderToList(Node node, List<Integer> out) {
246-
if (node == null) return;
252+
if (node == null) {
253+
return;
254+
}
247255
inorderToList(node.left, out);
248256
out.add(node.key);
249257
inorderToList(node.right, out);
@@ -275,4 +283,40 @@ private void postorderToList(Node node, List<Integer> out) {
275283
postorderToList(node.right, out);
276284
out.add(node.key);
277285
}
286+
287+
public static void main(String[] args) {
288+
BST bst = new BST();
289+
290+
// Insert values
291+
int[] values = {50, 30, 70, 20, 40, 60, 80};
292+
for (int v : values) {
293+
bst.insert(v);
294+
}
295+
296+
bst.printInorder();
297+
bst.printPreorder();
298+
bst.printPostorder();
299+
300+
System.out.println("Inorder List: " + bst.inorderList());
301+
System.out.println("Preorder List: " + bst.preorderList());
302+
System.out.println("Postorder List: " + bst.postorderList());
303+
304+
305+
System.out.println("Search 40: " + bst.search(40)); // true
306+
System.out.println("Search 99: " + bst.search(99)); // false
307+
308+
309+
System.out.println("Min: " + bst.findMin()); // 20
310+
System.out.println("Max: " + bst.findMax()); // 80
311+
312+
313+
bst.delete(20);
314+
System.out.println("After deleting 20 (leaf): " + bst.inorderList());
315+
316+
bst.delete(30);
317+
System.out.println("After deleting 30 (one child): " + bst.inorderList());
318+
319+
bst.delete(50);
320+
System.out.println("After deleting 50 (two children): " + bst.inorderList());
321+
}
278322
}

‎src/test/java/com/thealgorithms/tree/AVLTest.java‎

Lines changed: 18 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -89,19 +89,31 @@ public List<Integer> postorderList() {
8989
private Node insertRecursive(Node node, int key) {
9090
if (node == null) return new Node(key);
9191

92-
if (key < node.key) node.left = insertRecursive(node.left, key);
93-
else if (key > node.key) node.right = insertRecursive(node.right, key);
94-
else return node; // duplicates ignored
92+
if (key < node.key) {
93+
node.left = insertRecursive(node.left, key);
94+
}
95+
else if (key > node.key) {
96+
node.right = insertRecursive(node.right, key);
97+
}
98+
else {
99+
return node; // duplicates ignored
100+
}
95101

96102
updateHeight(node);
97103
return balanceNode(node);
98104
}
99105

100106
private Node deleteRecursive(Node node, int key) {
101-
if (node == null) return null;
107+
if (node == null) {
108+
return null;
109+
}
102110

103-
if (key < node.key) node.left = deleteRecursive(node.left, key);
104-
else if (key > node.key) node.right = deleteRecursive(node.right, key);
111+
if (key < node.key) {
112+
node.left = deleteRecursive(node.left, key);
113+
}
114+
else if (key > node.key) {
115+
node.right = deleteRecursive(node.right, key);
116+
}
105117
else {
106118
if (node.left == null || node.right == null) {
107119
Node temp = (node.left != null) ? node.left : node.right;

0 commit comments

Comments
 (0)