Skip to content

Commit a5fa14a

Browse files
committedAug 24, 2020
Implemented DF Traversals & BST Validator (Closes #11)
1 parent ef35827 commit a5fa14a

File tree

7 files changed

+247
-17
lines changed

7 files changed

+247
-17
lines changed
 

‎Algorithms/README.md

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -9,18 +9,20 @@
99
- [X] Bubble Sort
1010
- [X] Selection Sort
1111
- [X] Insertion Sort
12-
- [ ] Searching
13-
- [ ] Linear Search
12+
- [X] Searching
13+
- [X] Linear Search
1414
- [ ] Binary Search
15-
- [ ] Breadth First Search (BFS)
16-
- [ ] Depth First Search (DFS)
15+
- [X] Breadth First Search (BFS)
16+
- [X] Depth First Search (DFS)
1717

1818
## Resources
1919
- [Visualizing Data Structures & Algorithms](https://visualgo.net/en)
2020
- [Unicode Characters | RapidTables](https://www.rapidtables.com/code/text/unicode-characters.html)
2121
- [The Big-O Algorithm Complexity Cheat Sheet](https://www.bigocheatsheet.com/ "Big O Cheat Sheet")
2222

2323
### Searching
24+
- [Graph Traversals: VisuAlgo](https://visualgo.net/en/dfsbfs)
25+
- [Tree Traversals: Preorder, Inorder, & Postorder](https://www.geeksforgeeks.org/tree-traversals-inorder-preorder-and-postorder/)
2426
- [Space Complexity: BFS vs DFS](https://stackoverflow.com/questions/9844193/what-is-the-time-and-space-complexity-of-a-breadth-first-and-depth-first-tree-tr)
2527

2628
### Sorting

‎Algorithms/Recursion/BreadthFirstSearch.ts renamed to ‎Algorithms/Searching/BreadthFirstTraversal.ts

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -2,18 +2,18 @@ import BST from '../../Data-Structures/Trees/BinarySearchTree.ts';
22
import Node from '../../Data-Structures/Trees/BinaryTreeNode.ts';
33
import Queue from '../../Data-Structures/Sequential/Queue.ts';
44

5-
function recursiveBFS(nodeQueue: Queue<Node>, nodesTraversed: Array<number>): Array<number> {
5+
function recursiveBFT(nodeQueue: Queue<Node>, nodesTraversed: Array<number>): Array<number> {
66
if (nodeQueue.getLength() === 0) return nodesTraversed;
77

88
let currentNode: Node = nodeQueue.dequeue();
99
nodesTraversed.push(currentNode.getValue());
1010
if (currentNode.hasLeft()) nodeQueue.enqueue(currentNode.getLeft());
1111
if (currentNode.hasRight()) nodeQueue.enqueue(currentNode.getRight());
1212

13-
return recursiveBFS(nodeQueue, nodesTraversed);
13+
return recursiveBFT(nodeQueue, nodesTraversed);
1414
}
1515

16-
function breadthFirstSearch(tree: BST) {
16+
function breadthFirstTraversal(tree: BST) {
1717
const root = tree.getRoot();
1818

1919
if (!root) return false;
@@ -23,7 +23,7 @@ function breadthFirstSearch(tree: BST) {
2323

2424
nodeQueue.enqueue(root);
2525

26-
return recursiveBFS(nodeQueue, nodesTraversed);
26+
return recursiveBFT(nodeQueue, nodesTraversed);
2727
}
2828

2929

@@ -46,9 +46,9 @@ if (import.meta.main) {
4646
tree.insert(15);
4747
tree.insert(1);
4848

49-
console.log(breadthFirstSearch(tree));
49+
console.log(breadthFirstTraversal(tree));
5050

51-
// RUN: deno run Algorithms/Recursion/BreadthFirstSearch.ts
51+
// RUN: deno run Algorithms/Searching/BreadthFirstTraversal.ts
5252
}
5353

5454
// --------------------------- Terminal Output: ---------------------------
Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
import BST from '../../Data-Structures/Trees/BinarySearchTree.ts';
2+
import Node from '../../Data-Structures/Trees/BinaryTreeNode.ts';
3+
4+
5+
export function inorderDFT(tree: BST) {
6+
const root = tree.getRoot();
7+
if (!root) return false;
8+
9+
const nodesTraversed: number[] = [];
10+
11+
return traverseInOrder(root, nodesTraversed);
12+
13+
/**
14+
* Recursive DFS on Binary Search Tree via inorder traversal
15+
* @param node Binary node to traverse
16+
* @param nodesTraversed Array of all nodes reached inorder
17+
*/
18+
function traverseInOrder(node: Node, nodesTraversed: Array<number>) {
19+
if (node.hasLeft()) traverseInOrder(node.getLeft(), nodesTraversed);
20+
nodesTraversed.push(node.getValue());
21+
if (node.hasRight()) traverseInOrder(node.getRight(), nodesTraversed);
22+
return nodesTraversed;
23+
}
24+
}
25+
26+
export function preorderDFT(tree: BST) {
27+
const root = tree.getRoot();
28+
if (!root) return false;
29+
30+
const nodesTraversed: number[] = [];
31+
32+
return traversePreOrder(root, nodesTraversed);
33+
34+
/**
35+
* Recursive DFS on Binary Search Tree via preorder traversal
36+
* @param node Binary node to traverse
37+
* @param nodesTraversed Array of all nodes reached preorder
38+
*/
39+
function traversePreOrder(node: Node, nodesTraversed: Array<number>) {
40+
nodesTraversed.push(node.getValue());
41+
if (node.hasLeft()) traversePreOrder(node.getLeft(), nodesTraversed);
42+
if (node.hasRight()) traversePreOrder(node.getRight(), nodesTraversed);
43+
return nodesTraversed;
44+
}
45+
}
46+
47+
export function postorderDFT(tree: BST) {
48+
const root = tree.getRoot();
49+
if (!root) return false;
50+
51+
const nodesTraversed: number[] = [];
52+
53+
return traversePostOrder(root, nodesTraversed);
54+
55+
/**
56+
* Recursive DFS on Binary Search Tree via postorder traversal
57+
* @param node Binary node to traverse
58+
* @param nodesTraversed Array of all nodes reached postorder
59+
*/
60+
function traversePostOrder(node: Node, nodesTraversed: Array<number>) {
61+
if (node.hasLeft()) traversePostOrder(node.getLeft(), nodesTraversed);
62+
if (node.hasRight()) traversePostOrder(node.getRight(), nodesTraversed);
63+
nodesTraversed.push(node.getValue());
64+
return nodesTraversed;
65+
}
66+
}
67+
68+
69+
//---------------------------------------------------------------------
70+
// ---------- MAIN PROGRAM ----------
71+
//---------------------------------------------------------------------
72+
if (import.meta.main) {
73+
74+
const tree = new BST();
75+
76+
// 9
77+
// 4 20
78+
// 1 6 15 170
79+
80+
tree.insert(9);
81+
tree.insert(4);
82+
tree.insert(6);
83+
tree.insert(20);
84+
tree.insert(170);
85+
tree.insert(15);
86+
tree.insert(1);
87+
88+
console.log('Inorder:', inorderDFT(tree));
89+
console.log('Preorder:', preorderDFT(tree));
90+
console.log('Postorder:', postorderDFT(tree));
91+
92+
// RUN: deno run Algorithms/Searching/DepthFirstTraversals.ts
93+
}
94+
95+
// --------------------------- Terminal Output: ---------------------------

‎Data-Structures/README.md

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,7 @@
3434
- [AVL Tree Visualization](https://www.cs.usfca.edu/~galles/visualization/AVLtree.html)
3535
- [Red-Black Tree Visualization](https://www.cs.usfca.edu/~galles/visualization/RedBlack.html)
3636
- [Priority Queue Implementation: GeeksForGeeks](https://www.cs.usfca.edu/~galles/visualization/RedBlack.html)
37+
- [Validate a BST: GeeksForGeeks](https://www.geeksforgeeks.org/a-program-to-check-if-a-binary-tree-is-bst-or-not/)
3738

3839
### Hash Tables
3940
- [MD5 Hash Generator](http://www.miraclesalad.com/webtools/md5.php)

‎Data-Structures/Trees/BinarySearchTree.ts

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -206,7 +206,7 @@ export default class BinarySearchTree {
206206
node.setRight(left);
207207
}
208208

209-
public breadthFirstSearch() {
209+
public breadthFirstTraversal() {
210210
if (!this.root) return false;
211211

212212
let currentNode = this.root;
@@ -252,7 +252,7 @@ if (import.meta.main) {
252252
tree.insert(170);
253253
tree.insert(15);
254254
tree.insert(1);
255-
console.log(tree.breadthFirstSearch());
255+
console.log(tree.breadthFirstTraversal());
256256
// console.log('Tree: ', JSON.stringify(BinarySearchTree.traverse(tree.getRoot())));
257257
tree.remove(20);
258258
printNode(tree, 4);
@@ -263,7 +263,7 @@ if (import.meta.main) {
263263
tree.invertTree();
264264
console.log('Inverse Tree: ', JSON.stringify(BinarySearchTree.traverse(tree.getRoot())));
265265

266-
console.log(tree.breadthFirstSearch());
266+
console.log(tree.breadthFirstTraversal());
267267

268268
// RUN: deno run Data-Structures/Trees/BinarySearchTree.ts
269269
}

‎Playground/Challenges/ValidatorBST.ts

Lines changed: 132 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,132 @@
1+
import BST from '../../Data-Structures/Trees/BinarySearchTree.ts';
2+
import Node from '../../Data-Structures/Trees/BinaryTreeNode.ts';
3+
4+
export default class BinarySearchTreeValidator {
5+
private static previousVal: number | undefined = undefined;
6+
7+
private static _resetValidator() {
8+
this.previousVal = undefined;
9+
}
10+
11+
public static validate(tree: BST, visualize?: boolean): boolean {
12+
const root = tree.getRoot();
13+
if (!root) return false;
14+
15+
visualize = visualize || false;
16+
17+
const valid: boolean = this._traverseInOrder(root, visualize);
18+
19+
this._resetValidator();
20+
21+
return valid;
22+
}
23+
24+
private static _traverseInOrder(node: Node, visualize: boolean): boolean {
25+
if (node.hasLeft()) this._traverseInOrder(node.getLeft(), visualize);
26+
27+
const currentValue = node.getValue();
28+
if (visualize) console.log('\tCurrent Value:', node.getValue(), '\tPrevious:', this.previousVal);
29+
30+
if (!this.previousVal) this.previousVal = currentValue;
31+
else if (currentValue < this.previousVal) return false;
32+
else this.previousVal = currentValue;
33+
34+
if (node.hasRight()) this._traverseInOrder(node.getRight(), visualize);
35+
36+
return true;
37+
}
38+
}
39+
40+
function printBSTValidation(tree: BST, treeLabel: string) {
41+
console.log(treeLabel, '– Original:', BinarySearchTreeValidator.validate(tree, true));
42+
}
43+
44+
45+
46+
//---------------------------------------------------------------------
47+
// ---------- MAIN PROGRAM ----------
48+
//---------------------------------------------------------------------
49+
if (import.meta.main) {
50+
51+
const tree1 = new BST();
52+
tree1.insert(9);
53+
tree1.insert(4);
54+
tree1.insert(6);
55+
tree1.insert(20);
56+
tree1.insert(170);
57+
tree1.insert(15);
58+
tree1.insert(1);
59+
60+
// 9
61+
// 4 20
62+
// 1 6 15 170
63+
printBSTValidation(tree1, 'Tree 1');
64+
65+
66+
tree1.invertTree();
67+
// 9
68+
// 20 4
69+
// 170 15 6 1
70+
printBSTValidation(tree1, 'Tree 1');
71+
72+
73+
const tree2 = new BST();
74+
tree2.insert(16);
75+
tree2.insert(8);
76+
tree2.insert(32);
77+
78+
printBSTValidation(tree2, 'Tree 2');
79+
tree2.invertTree();
80+
printBSTValidation(tree2, 'Tree 2');
81+
82+
83+
const tree3 = new BST();
84+
tree3.insert(48);
85+
tree3.insert(29);
86+
tree3.insert(77);
87+
tree3.insert(18);
88+
tree3.insert(16);
89+
tree3.insert(68);
90+
tree3.insert(72);
91+
tree3.insert(83);
92+
93+
printBSTValidation(tree3, 'Tree 3');
94+
tree3.invertTree();
95+
printBSTValidation(tree3, 'Tree 3');
96+
97+
// RUN: deno run Playground/Challenges/ValidatorBST.ts
98+
}
99+
100+
// --------------------------- Terminal Output: ---------------------------
101+
// Current Value: 1 Previous: undefined
102+
// Current Value: 4 Previous: 1
103+
// Current Value: 6 Previous: 4
104+
// Current Value: 9 Previous: 6
105+
// Current Value: 15 Previous: 9
106+
// Current Value: 20 Previous: 15
107+
// Current Value: 170 Previous: 20
108+
// Tree 1 – Original: true
109+
// Current Value: 170 Previous: undefined
110+
// Current Value: 20 Previous: 170
111+
// Current Value: 9 Previous: 170
112+
// Tree 1 – Original: false
113+
// Current Value: 8 Previous: undefined
114+
// Current Value: 16 Previous: 8
115+
// Current Value: 32 Previous: 16
116+
// Tree 2 – Original: true
117+
// Current Value: 32 Previous: undefined
118+
// Current Value: 16 Previous: 32
119+
// Tree 2 – Original: false
120+
// Current Value: 16 Previous: undefined
121+
// Current Value: 18 Previous: 16
122+
// Current Value: 29 Previous: 18
123+
// Current Value: 48 Previous: 29
124+
// Current Value: 68 Previous: 48
125+
// Current Value: 72 Previous: 68
126+
// Current Value: 77 Previous: 72
127+
// Current Value: 83 Previous: 77
128+
// Tree 3 – Original: true
129+
// Current Value: 83 Previous: undefined
130+
// Current Value: 77 Previous: 83
131+
// Current Value: 48 Previous: 83
132+
// Tree 3 – Original: false

‎README.md

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -22,10 +22,10 @@
2222
- [X] Comparison Sorting
2323
- [X] *Merge Sort*
2424
- [X] *Quicksort*
25-
- [ ] Searching
26-
- [ ] Linear Search
27-
- [ ] Binary Search
28-
- [ ] BFS & DFS
25+
- [X] Searching
26+
- [X] Linear Search
27+
- [X] Binary Search
28+
- [X] BFS & DFS
2929

3030
## Environment
3131
- Deno 1.2.1

0 commit comments

Comments
 (0)
Please sign in to comment.