algorithm/JavaScript
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/JavaScript.git synced 2026-03-13 15:21:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

npx standard --fix

Browse Source
This commit is contained in:
cclauss
2020-05-03 09:05:12 +02:00
parent e62ad2f73e
commit 856dc2f63c
47 changed files with 2240 additions and 2371 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
Data Structures/Graph/Graph.js
View File

@@ -1,50 +1,44 @@
class Graph {
constructor () {
this.adjacencyMap = {}
}
constructor() {
this.adjacencyMap = {}
addVertex (v) {
this.adjacencyMap[v] = []
}
containsVertex (vertex) {
return typeof (this.adjacencyMap[vertex]) !== 'undefined'
}
addEdge (v, w) {
let result = false
if (this.containsVertex(v) && this.containsVertex(w)) {
this.adjacencyMap[v].push(w)
this.adjacencyMap[w].push(v)
result = true
}
return result
}
addVertex(v) {
this.adjacencyMap[v] = [];
printGraph () {
const keys = Object.keys(this.adjacencyMap)
for (const i of keys) {
const values = this.adjacencyMap[i]
let vertex = ''
for (const j of values) { vertex += j + ' ' }
console.log(i + ' -> ' + vertex)
}
containsVertex(vertex) {
return typeof (this.adjacencyMap[vertex]) !== "undefined"
}
addEdge(v, w) {
let result = false
if (this.containsVertex(v) && this.containsVertex(w)) {
this.adjacencyMap[v].push(w);
this.adjacencyMap[w].push(v);
result = true
}
return result
}
printGraph() {
let keys = Object.keys(this.adjacencyMap);
for (let i of keys) {
let values = this.adjacencyMap[i];
let vertex = "";
for (let j of values)
vertex += j + " ";
console.log(i + " -> " + vertex);
}
}
}
}
const example = () => {
let g = new Graph()
g.addVertex(1)
g.addVertex(2)
g.addVertex(3)
g.addEdge(1, 2)
g.addEdge(1, 3)
g.printGraph()
}
const g = new Graph()
g.addVertex(1)
g.addVertex(2)
g.addVertex(3)
g.addEdge(1, 2)
g.addEdge(1, 3)
g.printGraph()
}

150
Data Structures/Heap/MinPriorityQueue.js
View File

@@ -1,8 +1,8 @@
/* Minimum Priority Queue
* It is a part of heap data structure
* A heap is a specific tree based data structure
* in which all the nodes of tree are in a specific order.
* A heap is a specific tree based data structure
* in which all the nodes of tree are in a specific order.
* that is the children are arranged in some
* respect of their parents, can either be greater
* or less than the parent. This makes it a min priority queue
@@ -12,117 +12,115 @@
// Functions: insert, delete, peek, isEmpty, print, heapSort, sink
class MinPriorityQueue {
// calss the constructor and initializes the capacity
constructor(c) {
this.heap = [];
this.capacity = c;
this.size = 0;
// calss the constructor and initializes the capacity
constructor (c) {
this.heap = []
this.capacity = c
this.size = 0
}
// inserts the key at the end and rearranges it
// so that the binary heap is in appropriate order
insert(key) {
if (this.isFull()) return;
this.heap[this.size + 1] = key;
let k = this.size + 1;
// inserts the key at the end and rearranges it
// so that the binary heap is in appropriate order
insert (key) {
if (this.isFull()) return
this.heap[this.size + 1] = key
let k = this.size + 1
while (k > 1) {
if (this.heap[k] < this.heap[Math.floor(k / 2)]) {
let temp = this.heap[k];
this.heap[k] = this.heap[Math.floor(k / 2)];
this.heap[Math.floor(k / 2)] = temp;
const temp = this.heap[k]
this.heap[k] = this.heap[Math.floor(k / 2)]
this.heap[Math.floor(k / 2)] = temp
}
k = Math.floor(k / 2);
k = Math.floor(k / 2)
}
this.size++;
this.size++
}
// returns the highest priority value
peek() {
return this.heap[1];
// returns the highest priority value
peek () {
return this.heap[1]
}
// returns boolean value whether the heap is empty or not
isEmpty() {
if (0 == this.size) return true;
return false;
// returns boolean value whether the heap is empty or not
isEmpty () {
if (this.size == 0) return true
return false
}
// returns boolean value whether the heap is full or not
isFull() {
if (this.size == this.capacity) return true;
return false;
// returns boolean value whether the heap is full or not
isFull () {
if (this.size == this.capacity) return true
return false
}
// prints the heap
print() {
console.log(this.heap.slice(1));
// prints the heap
print () {
console.log(this.heap.slice(1))
}
// heap sorting can be done by performing
// delete function to the number of times of the size of the heap
// it returns reverse sort because it is a min priority queue
heapSort() {
// heap sorting can be done by performing
// delete function to the number of times of the size of the heap
// it returns reverse sort because it is a min priority queue
heapSort () {
for (let i = 1; i < this.capacity; i++) {
this.delete();
}
this.delete()
}
}
// this function reorders the heap after every delete function
sink() {
let k = 1;
// this function reorders the heap after every delete function
sink () {
let k = 1
while (2 * k <= this.size || 2 * k + 1 <= this.size) {
let minIndex;
let minIndex
if (this.heap[2 * k] >= this.heap[k]) {
if (2 * k + 1 <= this.size && this.heap[2*k+1] >= this.heap[k]) {
break;
}
else if(2*k+1 > this.size){
break;
}
if (2 * k + 1 <= this.size && this.heap[2 * k + 1] >= this.heap[k]) {
break
} else if (2 * k + 1 > this.size) {
break
}
}
if (2 * k + 1 > this.size) {
minIndex = this.heap[2 * k] < this.heap[k] ? 2 * k : k;
minIndex = this.heap[2 * k] < this.heap[k] ? 2 * k : k
} else {
if (
this.heap[k] > this.heap[2 * k] ||
this.heap[k] > this.heap[2 * k + 1]
) {
minIndex =
this.heap[2 * k] < this.heap[2 * k + 1] ? 2 * k : 2 * k + 1;
this.heap[2 * k] < this.heap[2 * k + 1] ? 2 * k : 2 * k + 1
} else {
minIndex = k;
minIndex = k
}
}
let temp = this.heap[k];
this.heap[k] = this.heap[minIndex];
this.heap[minIndex] = temp;
k = minIndex;
const temp = this.heap[k]
this.heap[k] = this.heap[minIndex]
this.heap[minIndex] = temp
k = minIndex
}
}
// deletes the highest priority value from the heap
delete() {
let min = this.heap[1];
this.heap[1] = this.heap[this.size];
this.heap[this.size] = min;
this.size--;
this.sink();
return min;
// deletes the highest priority value from the heap
delete () {
const min = this.heap[1]
this.heap[1] = this.heap[this.size]
this.heap[this.size] = min
this.size--
this.sink()
return min
}
}
// testing
q = new MinPriorityQueue(8);
q = new MinPriorityQueue(8)
q.insert(5);
q.insert(2);
q.insert(4);
q.insert(1);
q.insert(7);
q.insert(6);
q.insert(3);
q.insert(8);
q.print(); // [ 1, 2, 3, 5, 7, 6, 4, 8 ]
q.heapSort();
q.print(); // [ 8, 7, 6, 5, 4, 3, 2, 1 ]
q.insert(5)
q.insert(2)
q.insert(4)
q.insert(1)
q.insert(7)
q.insert(6)
q.insert(3)
q.insert(8)
q.print() // [ 1, 2, 3, 5, 7, 6, 4, 8 ]
q.heapSort()
q.print() // [ 8, 7, 6, 5, 4, 3, 2, 1 ]

370
Data Structures/Linked List/DoublyLinkedList.js
View File

@@ -1,197 +1,195 @@
//Hamza chabchoub contribution for a university project
function doubleLinkedList() {
let Node = function(element) {
this.element = element;
this.next = null;
this.prev = null;
// Hamza chabchoub contribution for a university project
function doubleLinkedList () {
const Node = function (element) {
this.element = element
this.next = null
this.prev = null
}
let length = 0
let head = null
let tail = null
// Add new element
this.append = function (element) {
const node = new Node(element)
if (!head) {
head = node
tail = node
} else {
node.prev = tail
tail.next = node
tail = node
}
let length = 0;
let head = null;
let tail = null;
//Add new element
this.append = function(element) {
let node = new Node(element);
if(!head){
head = node;
tail = node;
}else{
node.prev = tail;
tail.next = node;
tail = node;
}
length++;
}
//Add element
this.insert = function(position, element) {
//Check of out-of-bound values
if(position >= 0 && position <= length){
let node = new Node(element),
current = head,
previous,
index = 0;
if(position === 0){
if(!head){
head = node;
tail = node;
}else{
node.next = current;
current.prev = node;
head = node;
}
}else if(position === length){
current = tail;
current.next = node;
node.prev = current;
tail = node;
}else{
while(index++ < position){
previous = current;
current = current.next;
}
node.next = current;
previous.next = node;
//New
current.prev = node;
node.prev = previous;
length++
}
// Add element
this.insert = function (position, element) {
// Check of out-of-bound values
if (position >= 0 && position <= length) {
const node = new Node(element)
let current = head
let previous
let index = 0
if (position === 0) {
if (!head) {
head = node
tail = node
} else {
node.next = current
current.prev = node
head = node
}
length++;
return true;
}else{
return false;
}
}
//Remove element at any position
this.removeAt = function(position){
//look for out-of-bounds value
if(position > -1 && position < length){
let current = head, previous, index = 0;
//Removing first item
if(position === 0){
head = current.next;
//if there is only one item, update tail //NEW
if(length === 1){
tail = null;
}else{
head.prev = null;
}
}else if(position === length - 1){
current = tail;
tail = current.prev;
tail.next = null;
}else{
while(index++ < position){
previous = current;
current = current.next;
}
//link previous with current's next - skip it
previous.next = current.next;
current.next.prev = previous;
} else if (position === length) {
current = tail
current.next = node
node.prev = current
tail = node
} else {
while (index++ < position) {
previous = current
current = current.next
}
length--;
return current.element;
}else{
return null;
node.next = current
previous.next = node
// New
current.prev = node
node.prev = previous
}
length++
return true
} else {
return false
}
//Get the indexOf item
this.indexOf = function(elm){
let current = head,
index = -1;
//If element found then return its position
while(current){
if(elm === current.element){
return ++index;
}
// Remove element at any position
this.removeAt = function (position) {
// look for out-of-bounds value
if (position > -1 && position < length) {
let current = head; let previous; let index = 0
// Removing first item
if (position === 0) {
head = current.next
// if there is only one item, update tail //NEW
if (length === 1) {
tail = null
} else {
head.prev = null
}
index++;
current = current.next;
}
//Else return -1
return -1;
};
//Find the item in the list
this.isPresent = (elm) => {
return this.indexOf(elm) !== -1;
};
//Delete an item from the list
this.delete = (elm) => {
return this.removeAt(this.indexOf(elm));
};
//Delete first item from the list
this.deleteHead = function(){
this.removeAt(0);
}
//Delete last item from the list
this.deleteTail = function(){
this.removeAt(length-1);
}
//Print item of the string
this.toString = function(){
let current = head,
string = '';
while(current){
string += current.element + (current.next ? '\n' : '');
current = current.next;
} else if (position === length - 1) {
current = tail
tail = current.prev
tail.next = null
} else {
while (index++ < position) {
previous = current
current = current.next
}
// link previous with current's next - skip it
previous.next = current.next
current.next.prev = previous
}
return string;
};
//Convert list to array
this.toArray = function(){
let arr = [],
current = head;
while(current){
arr.push(current.element);
current = current.next;
length--
return current.element
} else {
return null
}
}
// Get the indexOf item
this.indexOf = function (elm) {
let current = head
let index = -1
// If element found then return its position
while (current) {
if (elm === current.element) {
return ++index
}
return arr;
};
//Check if list is empty
this.isEmpty = function(){
return length === 0;
};
//Get the size of the list
this.size = function(){
return length;
index++
current = current.next
}
//Get the head
this.getHead = function() {
return head;
// Else return -1
return -1
}
// Find the item in the list
this.isPresent = (elm) => {
return this.indexOf(elm) !== -1
}
// Delete an item from the list
this.delete = (elm) => {
return this.removeAt(this.indexOf(elm))
}
// Delete first item from the list
this.deleteHead = function () {
this.removeAt(0)
}
// Delete last item from the list
this.deleteTail = function () {
this.removeAt(length - 1)
}
// Print item of the string
this.toString = function () {
let current = head
let string = ''
while (current) {
string += current.element + (current.next ? '\n' : '')
current = current.next
}
//Get the tail
this.getTail = function() {
return tail;
return string
}
// Convert list to array
this.toArray = function () {
const arr = []
let current = head
while (current) {
arr.push(current.element)
current = current.next
}
}
return arr
}
// Check if list is empty
this.isEmpty = function () {
return length === 0
}
// Get the size of the list
this.size = function () {
return length
}
// Get the head
this.getHead = function () {
return head
}
// Get the tail
this.getTail = function () {
return tail
}
}

260
Data Structures/Linked List/singlylinklist.js
View File

@@ -6,212 +6,204 @@
* a singly linked list.
*/
//Functions - add, remove, indexOf, elementAt, addAt, removeAt, view
// Functions - add, remove, indexOf, elementAt, addAt, removeAt, view
// class LinkedList and constructor
//Creates a LinkedList
// Creates a LinkedList
var LinkedList = (function () {
function LinkedList() {
//Length of linklist and head is null at start
this.length = 0;
this.head = null;
function LinkedList () {
// Length of linklist and head is null at start
this.length = 0
this.head = null
}
// class node (constructor)
//Creating Node with element's value
// Creating Node with element's value
var Node = (function () {
function Node(element) {
this.element = element;
this.next = null;
function Node (element) {
this.element = element
this.next = null
}
return Node;
}());
return Node
}())
//Returns length
// Returns length
LinkedList.prototype.size = function () {
return this.length;
};
return this.length
}
//Returns the head
// Returns the head
LinkedList.prototype.head = function () {
return this.head;
};
return this.head
}
//Creates a node and adds it to linklist
// Creates a node and adds it to linklist
LinkedList.prototype.add = function (element) {
var node = new Node(element);
//Check if its the first element
var node = new Node(element)
// Check if its the first element
if (this.head === null) {
this.head = node;
}
else {
var currentNode = this.head;
this.head = node
} else {
var currentNode = this.head
//Loop till there is node present in the list
// Loop till there is node present in the list
while (currentNode.next) {
currentNode = currentNode.next;
currentNode = currentNode.next
}
//Adding node to the end of the list
currentNode.next = node;
// Adding node to the end of the list
currentNode.next = node
}
//Increment the length
this.length++;
};
// Increment the length
this.length++
}
//Removes the node with the value as param
// Removes the node with the value as param
LinkedList.prototype.remove = function (element) {
var currentNode = this.head;
var previousNode;
var currentNode = this.head
var previousNode
//Check if the head node is the element to remove
// Check if the head node is the element to remove
if (currentNode.element === element) {
this.head = currentNode.next;
}
else {
//Check which node is the node to remove
this.head = currentNode.next
} else {
// Check which node is the node to remove
while (currentNode.element !== element) {
previousNode = currentNode;
currentNode = currentNode.next;
previousNode = currentNode
currentNode = currentNode.next
}
//Removing the currentNode
previousNode.next = currentNode.next;
// Removing the currentNode
previousNode.next = currentNode.next
}
//Decrementing the length
this.length--;
};
// Decrementing the length
this.length--
}
//Return if the list is empty
// Return if the list is empty
LinkedList.prototype.isEmpty = function () {
return this.length === 0;
};
return this.length === 0
}
//Returns the index of the element passed as param otherwise -1
// Returns the index of the element passed as param otherwise -1
LinkedList.prototype.indexOf = function (element) {
var currentNode = this.head;
var index = -1;
var currentNode = this.head
var index = -1
while (currentNode) {
index++;
index++
//Checking if the node is the element we are searching for
// Checking if the node is the element we are searching for
if (currentNode.element === element) {
return index + 1;
return index + 1
}
currentNode = currentNode.next;
currentNode = currentNode.next
}
return -1;
};
return -1
}
//Returns the element at an index
// Returns the element at an index
LinkedList.prototype.elementAt = function (index) {
var currentNode = this.head;
var count = 0;
var currentNode = this.head
var count = 0
while (count < index) {
count++;
currentNode = currentNode.next;
count++
currentNode = currentNode.next
}
return currentNode.element;
};
return currentNode.element
}
//Adds the element at specified index
// Adds the element at specified index
LinkedList.prototype.addAt = function (index, element) {
index--;
var node = new Node(element);
index--
var node = new Node(element)
var currentNode = this.head;
var previousNode;
var currentIndex = 0;
var currentNode = this.head
var previousNode
var currentIndex = 0
//Check if index is out of bounds of list
// Check if index is out of bounds of list
if (index > this.length) {
return false;
return false
}
//Check if index is the start of list
// Check if index is the start of list
if (index === 0) {
node.next = currentNode;
this.head = node;
}
else {
node.next = currentNode
this.head = node
} else {
while (currentIndex < index) {
currentIndex++;
previousNode = currentNode;
currentNode = currentNode.next;
currentIndex++
previousNode = currentNode
currentNode = currentNode.next
}
//Adding the node at specified index
node.next = currentNode;
previousNode.next = node;
// Adding the node at specified index
node.next = currentNode
previousNode.next = node
}
//Incrementing the length
this.length++;
return true;
};
// Incrementing the length
this.length++
return true
}
//Removes the node at specified index
// Removes the node at specified index
LinkedList.prototype.removeAt = function (index) {
index--;
var currentNode = this.head;
var previousNode;
var currentIndex = 0;
index--
var currentNode = this.head
var previousNode
var currentIndex = 0
//Check if index is present in list
// Check if index is present in list
if (index < 0 || index >= this.length) {
return null;
return null
}
//Check if element is the first element
// Check if element is the first element
if (index === 0) {
this.head = currentNode.next;
}
else {
this.head = currentNode.next
} else {
while (currentIndex < index) {
currentIndex++;
previousNode = currentNode;
currentNode = currentNode.next;
currentIndex++
previousNode = currentNode
currentNode = currentNode.next
}
previousNode.next = currentNode.next;
previousNode.next = currentNode.next
}
//Decrementing the length
this.length--;
return currentNode.element;
};
// Decrementing the length
this.length--
return currentNode.element
}
//Function to view the LinkedList
// Function to view the LinkedList
LinkedList.prototype.view = function () {
var currentNode = this.head;
var count = 0;
var currentNode = this.head
var count = 0
while (count < this.length) {
count++;
console.log(currentNode.element);
currentNode = currentNode.next;
count++
console.log(currentNode.element)
currentNode = currentNode.next
}
};
}
// returns the constructor
return LinkedList;
return LinkedList
}())
}());
//Implementation of LinkedList
var linklist = new LinkedList();
linklist.add(2);
linklist.add(5);
linklist.add(8);
linklist.add(12);
linklist.add(17);
console.log(linklist.size());
console.log(linklist.removeAt(4));
linklist.addAt(4, 15);
console.log(linklist.indexOf(8));
console.log(linklist.size());
linklist.view();
// Implementation of LinkedList
var linklist = new LinkedList()
linklist.add(2)
linklist.add(5)
linklist.add(8)
linklist.add(12)
linklist.add(17)
console.log(linklist.size())
console.log(linklist.removeAt(4))
linklist.addAt(4, 15)
console.log(linklist.indexOf(8))
console.log(linklist.size())
linklist.view()

96
Data Structures/Queue/Queue.js
View File

@@ -5,80 +5,76 @@
* implementation uses an array to store the queue.
*/
//Functions: enqueue, dequeue, peek, view, length
// Functions: enqueue, dequeue, peek, view, length
var Queue = (function () {
// constructor
function Queue() {
//This is the array representation of the queue
this.queue = [];
function Queue () {
// This is the array representation of the queue
this.queue = []
}
// methods
//Add a value to the end of the queue
// methods
// Add a value to the end of the queue
Queue.prototype.enqueue = function (item) {
this.queue[this.queue.length] = item;
};
this.queue[this.queue.length] = item
}
//Removes the value at the front of the queue
// Removes the value at the front of the queue
Queue.prototype.dequeue = function () {
if (this.queue.length === 0) {
throw "Queue is Empty";
throw 'Queue is Empty'
}
var result = this.queue[0];
this.queue.splice(0, 1); //remove the item at position 0 from the array
var result = this.queue[0]
this.queue.splice(0, 1) // remove the item at position 0 from the array
return result;
};
return result
}
//Return the length of the queue
// Return the length of the queue
Queue.prototype.length = function () {
return this.queue.length;
};
return this.queue.length
}
//Return the item at the front of the queue
// Return the item at the front of the queue
Queue.prototype.peek = function () {
return this.queue[0];
};
return this.queue[0]
}
//List all the items in the queue
// List all the items in the queue
Queue.prototype.view = function () {
console.log(this.queue);
};
console.log(this.queue)
}
return Queue;
return Queue
}())
}());
// Implementation
var myQueue = new Queue()
//Implementation
var myQueue = new Queue();
myQueue.enqueue(1)
myQueue.enqueue(5)
myQueue.enqueue(76)
myQueue.enqueue(69)
myQueue.enqueue(32)
myQueue.enqueue(54)
myQueue.enqueue(1);
myQueue.enqueue(5);
myQueue.enqueue(76);
myQueue.enqueue(69);
myQueue.enqueue(32);
myQueue.enqueue(54);
myQueue.view()
myQueue.view();
console.log("Length: " + myQueue.length());
console.log("Front item: " + myQueue.peek());
console.log("Removed " + myQueue.dequeue() + " from front.");
console.log("New front item: " + myQueue.peek());
console.log("Removed " + myQueue.dequeue() + " from front.");
console.log("New front item: " + myQueue.peek());
myQueue.enqueue(55);
console.log("Inserted 55");
console.log("New front item: " + myQueue.peek());
console.log('Length: ' + myQueue.length())
console.log('Front item: ' + myQueue.peek())
console.log('Removed ' + myQueue.dequeue() + ' from front.')
console.log('New front item: ' + myQueue.peek())
console.log('Removed ' + myQueue.dequeue() + ' from front.')
console.log('New front item: ' + myQueue.peek())
myQueue.enqueue(55)
console.log('Inserted 55')
console.log('New front item: ' + myQueue.peek())
for (var i = 0; i < 5; i++) {
myQueue.dequeue();
myQueue.view();
myQueue.dequeue()
myQueue.view()
}
//console.log(myQueue.dequeue()); // throws exception!
// console.log(myQueue.dequeue()); // throws exception!

99
Data Structures/Stack/Stack.js
View File

@@ -7,69 +7,66 @@
// Functions: push, pop, peek, view, length
//Creates a stack constructor
// Creates a stack constructor
var Stack = (function () {
function Stack() {
//The top of the Stack
this.top = 0;
//The array representation of the stack
this.stack = new Array();
function Stack () {
// The top of the Stack
this.top = 0
// The array representation of the stack
this.stack = new Array()
}
//Adds a value onto the end of the stack
// Adds a value onto the end of the stack
Stack.prototype.push = function (value) {
this.stack[this.top] = value;
this.top++;
};
this.stack[this.top] = value
this.top++
}
//Removes and returns the value at the end of the stack
// Removes and returns the value at the end of the stack
Stack.prototype.pop = function () {
if (this.top === 0) {
return "Stack is Empty";
return 'Stack is Empty'
}
this.top--;
var result = this.stack[this.top];
delete this.stack[this.top];
return result;
};
//Returns the size of the stack
Stack.prototype.size = function () {
return this.top;
};
//Returns the value at the end of the stack
Stack.prototype.peek = function () {
return this.stack[this.top - 1];
this.top--
var result = this.stack[this.top]
delete this.stack[this.top]
return result
}
//To see all the elements in the stack
// Returns the size of the stack
Stack.prototype.size = function () {
return this.top
}
// Returns the value at the end of the stack
Stack.prototype.peek = function () {
return this.stack[this.top - 1]
}
// To see all the elements in the stack
Stack.prototype.view = function () {
for (var i = 0; i < this.top; i++)
console.log(this.stack[i]);
};
for (var i = 0; i < this.top; i++) { console.log(this.stack[i]) }
}
return Stack;
return Stack
}())
}());
// Implementation
var myStack = new Stack()
//Implementation
var myStack = new Stack();
myStack.push(1);
myStack.push(5);
myStack.push(76);
myStack.push(69);
myStack.push(32);
myStack.push(54);
console.log(myStack.size());
console.log(myStack.peek());
console.log(myStack.pop());
console.log(myStack.peek());
console.log(myStack.pop());
console.log(myStack.peek());
myStack.push(55);
console.log(myStack.peek());
myStack.view();
myStack.push(1)
myStack.push(5)
myStack.push(76)
myStack.push(69)
myStack.push(32)
myStack.push(54)
console.log(myStack.size())
console.log(myStack.peek())
console.log(myStack.pop())
console.log(myStack.peek())
console.log(myStack.pop())
console.log(myStack.peek())
myStack.push(55)
console.log(myStack.peek())
myStack.view()

92
Data Structures/Tree/Binary Search Tree.js
View File

@@ -1,4 +1,4 @@
/*Binary Search Tree!!
/* Binary Search Tree!!
*
* Nodes that will go on the Binary Tree.
* They consist of the data in them, the node to the left, the node
@@ -13,104 +13,102 @@
// class Node
var Node = (function () {
// Node in the tree
function Node(val) {
this.value = val;
this.left = null;
this.right = null;
function Node (val) {
this.value = val
this.left = null
this.right = null
}
// Search the tree for a value
Node.prototype.search = function (val) {
if (this.value == val) {
return this;
return this
} else if (val < this.value && this.left != null) {
return this.left.search(val);
return this.left.search(val)
} else if (val > this.value && this.right != null) {
return this.right.search(val);
return this.right.search(val)
}
return null;
};
return null
}
// Visit a node
Node.prototype.visit = function () {
// Recursively go left
if (this.left != null) {
this.left.visit();
this.left.visit()
}
// Print out value
console.log(this.value);
console.log(this.value)
// Recursively go right
if (this.right != null) {
this.right.visit();
this.right.visit()
}
};
}
// Add a node
Node.prototype.addNode = function (n) {
if (n.value < this.value) {
if (this.left == null) {
this.left = n;
this.left = n
} else {
this.left.addNode(n)
}
} else if (n.value > this.value) {
if (this.right == null) {
this.right = n;
this.right = n
} else {
this.right.addNode(n);
this.right.addNode(n)
}
}
};
}
// returns the constructor
return Node;
}());
return Node
}())
// class Tree
var Tree = (function () {
function Tree() {
function Tree () {
// Just store the root
this.root = null;
this.root = null
};
// Inorder traversal
Tree.prototype.traverse = function () {
this.root.visit();
};
this.root.visit()
}
// Start by searching the root
Tree.prototype.search = function (val) {
let found = this.root.search(val);
const found = this.root.search(val)
if (found === null) {
console.log(val + " not found");
console.log(val + ' not found')
} else {
console.log('Found:' + found.value)
}
else {
console.log("Found:" + found.value);
}
};
}
// Add a new value to the tree
Tree.prototype.addValue = function (val) {
let n = new Node(val);
const n = new Node(val)
if (this.root == null) {
this.root = n;
this.root = n
} else {
this.root.addNode(n);
this.root.addNode(n)
}
};
}
// returns the constructor
return Tree;
}());
return Tree
}())
//Implementation of BST
var bst = new Tree();
bst.addValue(6);
bst.addValue(3);
bst.addValue(9);
bst.addValue(2);
bst.addValue(8);
bst.addValue(4);
bst.traverse();
bst.search(8);
// Implementation of BST
var bst = new Tree()
bst.addValue(6)
bst.addValue(3)
bst.addValue(9)
bst.addValue(2)
bst.addValue(8)
bst.addValue(4)
bst.traverse()
bst.search(8)