DEV Community: Aashish Panchal

print 3 using C#

Aashish Panchal — Thu, 24 Dec 2020 13:32:54 +0000

class Program
{
static void Main(string[] args)

    { // 1
        for (int i = 1; i <= 3; i++)
            for (int j = 1; j <= 20; j++)
            {
                Console.Write("*");
                if (j == 20)
                    Console.Write("\n");
            }


        // 2
        for (int i = 1; i <= 3; i++)
        {
            for (int k = 1; k <= 13; k++) Console.Write(" ");

            for (int j = 1; j <= 7; j++)
            {
                Console.Write("*");
                if (j == 7)
                    Console.Write("\n");
            }
        }
        // 3
        for (int i = 1; i <= 3; i++)
            for (int j = 1; j <= 20; j++)
            {
                Console.Write("*");
                if (j == 20)
                    Console.Write("\n");
            }

        // 4
        for (int i = 1; i <= 3; i++)
        {
            for (int k = 1; k <= 13; k++) Console.Write(" ");

            for (int j = 1; j <= 7; j++)
            {
                Console.Write("*");
                if (j == 7)
                    Console.Write("\n");
            }
        }

        // 3
        for (int i = 1; i <= 3; i++)
            for (int j = 1; j <= 20; j++)
            {
                Console.Write("*");
                if (j == 20)
                    Console.Write("\n");
            }
    }
}

Output:-

********************
********************
********************
             *******
             *******
             *******
********************
********************
********************
             *******
             *******
             *******
********************
********************
********************

print 2 using C#

Aashish Panchal — Thu, 24 Dec 2020 13:31:05 +0000

class Program
{
static void Main(string[] args)

    { 
        // 1
        for (int i = 1; i <= 3; i++)
            for (int j = 1; j <= 20; j++)
            {
                Console.Write("*");
                if (j == 20)
                    Console.Write("\n");
            }


        // 2
        for (int i = 1; i <= 3; i++)
        {
            for (int k = 1; k <= 13; k++) Console.Write(" ");

            for (int j = 1; j <= 7; j++)
            {
                Console.Write("*");
                if (j == 7)
                    Console.Write("\n");
            }
        }
        // 3
        for (int i = 1; i <= 3; i++)
            for (int j = 1; j <= 20; j++)
            {
                Console.Write("*");
                if (j == 20)
                    Console.Write("\n");
            }

        // 4
        for (int i = 1; i <= 3; i++)
        {
            //for (int k = 1; k <= 13; k++) Console.Write(" ");

            for (int j = 1; j <= 7; j++)
            {
                Console.Write("*");
                if (j == 7)
                    Console.Write("\n");
            }
        }

        // 5
        for (int i = 1; i <= 3; i++)
            for (int j = 1; j <= 20; j++)
            {
                Console.Write("*");
                if (j == 20)
                    Console.Write("\n");
            }
    }
}

Output:-

********************
********************
********************
             *******
             *******
             *******
********************
********************
********************
*******
*******
*******
********************
********************
********************

Print 1 using C#

Aashish Panchal — Thu, 24 Dec 2020 13:26:57 +0000

class Program
{
static void Main(string[] args)

    {// 1
        for (int i = 1; i <= 3; i++)
            for (int j = 1; j <= 20; j++)
            {
                Console.Write("*");
                if (j == 20)
                    Console.Write("\n");
            }


        // 2
        for (int i = 1; i <= 3; i++)
        {
            for (int k = 1; k <= 13; k++) Console.Write(" ");

            for (int j = 1; j <= 7; j++)
            {
                Console.Write("*");
                if (j == 7)
                    Console.Write("\n");
            }
        }
        // 3
        for (int i = 1; i <= 7; i++)
        {
            for (int k = 1; k <= 13; k++) Console.Write(" ");

            for (int j = 1; j <= 7; j++)
            {
                Console.Write("*");
                if (j == 7)
                    Console.Write("\n");
            }
        }

        // 5
        for (int i = 1; i <= 3; i++)
            for (int j = 1; j <= 33; j++)
            {
                Console.Write("*");
                if (j == 33)
                    Console.Write("\n");
            }
    }
}

Output:-

********************
********************
********************
             *******
             *******
             *******
             *******
             *******
             *******
             *******
             *******
             *******
             *******
*********************************
*********************************
*********************************

Dijkstra Binary Heap PQ

Aashish Panchal — Fri, 30 Oct 2020 13:53:46 +0000

Last program of Java Script

    class weightedGraph {
        constructor() {
            this.adjacencyList = {};
        }
        addVertex(vertex) {
            if(!this.adjacencyList[vertex]) this.adjacencyList[vertex] = [];
            console.log(` ->   ${vertex}`)
        }

        addEdge(vertex1,vertex2, weight) {
            this.adjacencyList[vertex1].push({node: vertex2, weight});
            this.adjacencyList[vertex2].push({node :vertex1, weight});
            console.log(` ->   graph.addEdge ("${vertex1}", "${vertex2}", ${weight})`)
        }

        Dijkstra(start, finish) {
            const nodes = new PriorityQueue();
            const distances = {};
            const previous = {};
            let path = [] // to return at end
            let smallest

            // build up initial state
            for(let vertex in this.adjacencyList) {
                if(vertex === start) {
                    distances[vertex] = 0;
                    nodes.enqueue(vertex, 0);
                } else {
                    distances[vertex] = Infinity;
                    nodes.enqueue(vertex, Infinity);
                }
                previous[vertex] = null;
            }

            // As Long as there is Something to visit
            while(nodes.values.length) {
                smallest = nodes.dequeue().val;
                if(smallest === finish) {
                    // WE ARE DONE 
                    // BUILD UP PATH TO RETURN AT END 
                    while(previous[smallest]) {
                        path.push(smallest);
                        smallest = previous[smallest];
                    }
                    break;
                }
                if(smallest || distances[smallest] !== Infinity) {
                    for(let neighbor in this.adjacencyList[smallest]) {
                        // find neighboring node
                        let nextNode = this.adjacencyList[smallest][neighbor]; 
                        // Calculate new distances to neighboring node
                        let candidate = distances[smallest] + nextNode.weight;
                        let nextNeighbor = nextNode.node
                        if(candidate < distances[nextNeighbor]) {
                            // Upadating new smallest distance to neighbor 
                            distances[nextNeighbor] = candidate; 
                            // Upadating previous - How we got to neighbor
                            previous[nextNeighbor] = smallest;
                            // enqueue in priority queue with new priority
                            nodes.enqueue(nextNeighbor, candidate);
                        }
                    }
                }
             }
             console.log(path.concat(smallest).reverse());
        }
    }

    class priorityQueue {
        constructor() {
            this.values = []
        }
        enqueue(val, priority) {
            let newNode = new Node(val, priority)
            this.values.push(newNode);
            this.bubbleUp();
        }

        bubbleUp() {
            let idx = this.values.length - 1;
            const element = this.values[idx];
            while(idx > 0) {
                let parentIdx = Math.floor((idx - 1)/2);
                let parent = this.values[parentIdx];
                if(element.priority <= parent.priority) break;
                this.values[parentIdx] = element;
                this.values[idx] = parent;
                idx = parentIdx;
            }
        }

        dequeue () {
          const min = this.values[0];
          const end = this.values.pop();
              if(this.values.length > 0) {
              this.values[0] = end;
              this.sinkDown()
          }
          return min;
        }
        sinkDown() {
            let idx = 0;
            const length = this.values.length;
            const element = this.values[0];
            while(true) {
                let leftChildIdx = 2 * idx + 1;
                let rightChildIdx = 2 * idx + 2;
                let leftChild,rightChild;
                let swap = null;
                if(leftChildIdx < length) {
                    leftChild = this.values[leftChildIdx];
                    if(leftChild.priority < element.priority) {
                        swap = leftChildIdx; 
                    }
                }
                if(rightChildIdx < length) {
                    rightChild = this.values[rightChildIdx];
                    if(
                        (swap === null && rightChild.priority < element.priority) 
                                               ||
                        (swap !== null && rightChild.priority < leftChild.priority)
                     ) {
                        swap = rightChildIdx;
                    } 
                }

                if(swap === null) break;
                this.values[idx] = this.values[swap]
                this.values[swap] = element;
            }
        }
    }

    class Node {
        constructor(val, priority) {
            this.val = val;
            this.priority = priority;
        }
    }

    var graph = new weightedGraph();
    console.log("<---value--->")
    graph.addVertex("A")
    graph.addVertex("B")
    graph.addVertex("C")
    graph.addVertex("D")
    graph.addVertex("E")
    graph.addVertex("F")
    console.log("<---AddEdg value--->") 
    graph.addEdge("A", "B", 4);
    graph.addEdge("A", "C", 2);
    graph.addEdge("B", "E", 3);
    graph.addEdge("C", "D", 2);
    graph.addEdge("C", "F", 4);
    graph.addEdge("D", "E", 3);
    graph.addEdge("D", "F", 1);
    graph.addEdge("E", "F", 1);
    console.log("<---Dijkstra's value--->")
    graph.Dijkstra("A", "E");

Dijkstra First Version

Aashish Panchal — Fri, 30 Oct 2020 12:11:21 +0000

class PriorityQueue {
  constructor(){
    this.values = [];
  }
  enqueue(val, priority) {
    this.values.push({val, priority});
    this.sort();
    return values
  };
  dequeue() {
    return this.values.shift();
  };
  sort() {
    this.values.sort((a, b) => a.priority - b.priority);
  };
}

class weightedGraph {
    constructor() {
        this.adjacencyList = {};
    }
    addVertex(vertex) {
        if(!this.adjacencyList[vertex]) this.adjacencyList[vertex] = [];
        console.log(` ->   ${vertex}`)
    }

    addEdge(vertex1,vertex2, weight) {
        this.adjacencyList[vertex1].push({node: vertex2, weight});
        this.adjacencyList[vertex2].push({node :vertex1, weight});
        console.log(` ->   graph.addEdge ("${vertex1}", "${vertex2}", ${weight})`)
    }

    Dijkstra(start, finish) {
        const nodes = new PriorityQueue();
        const distances = {};
        const previous = {};
        let path = [] // to return at end
        let smallest

        // build up initial state
        for(let vertex in this.adjacencyList) {
            if(vertex === start) {
                distances[vertex] = 0;
                nodes.enqueue(vertex, 0);
            } else {
                distances[vertex] = Infinity;
                nodes.enqueue(vertex, Infinity);
            }
            previous[vertex] = null;
        }

        // As Long as there is Something to visit
        while(nodes.values.length) {
            smallest = nodes.dequeue().val;
            if(smallest === finish) {
                // WE ARE DONE 
                // BUILD UP PATH TO RETURN AT END 
                while(previous[smallest]) {
                    path.push(smallest);
                    smallest = previous[smallest];
                }
                break;
            }
            if(smallest || distances[smallest] !== Infinity) {
                for(let neighbor in this.adjacencyList[smallest]) {
                    // find neighboring node
                    let nextNode = this.adjacencyList[smallest][neighbor]; 
                    // Calculate new distances to neighboring node
                    let candidate = distances[smallest] + nextNode.weight;
                    let nextNeighbor = nextNode.node
                    if(candidate < distances[nextNeighbor]) {
                        // Upadating new smallest distance to neighbor 
                        distances[nextNeighbor] = candidate; 
                        // Upadating previous - How we got to neighbor
                        previous[nextNeighbor] = smallest;
                        // enqueue in priority queue with new priority
                        nodes.enqueue(nextNeighbor, candidate);
                    }
                }
            }
         }
         console.log(path.concat(smallest).reverse());
    }
}

var graph = new weightedGraph(); 
console.log("<---value--->")
graph.addVertex("A")
graph.addVertex("B")
graph.addVertex("C")
graph.addVertex("D")
graph.addVertex("E")
graph.addVertex("F")
console.log("<---AddEdg value--->") 
graph.addEdge("A", "B", 4);
graph.addEdge("A", "C", 2);
graph.addEdge("B", "E", 3);
graph.addEdge("C", "D", 2);
graph.addEdge("C", "F", 4);
graph.addEdge("D", "E", 3);
graph.addEdge("D", "F", 1);
graph.addEdge("E", "F", 1);
console.log("<---Dijkstra's value--->")
graph.Dijkstra("A", "E");

Graph Traversal

Aashish Panchal — Thu, 29 Oct 2020 13:30:42 +0000

class Graph {
    constructor() {
        this.adjacencyList = {};
    }
    addVertex(vertex) {
        if(!this.adjacencyList[vertex]) {
          this.adjacencyList[vertex] = [];  
        }
        return g;
    }

    addEdge(v1,v2) {
        this.adjacencyList[v1].push(v2);
        this.adjacencyList[v2].push(v1);
        return g;
    } 

    removeEdge(vertex1,vertex2) {
        this.adjacencyList[vertex1] = this.adjacencyList[vertex1].filter(
            v => v !== vertex2
        );
        this.adjacencyList[vertex2] = this.adjacencyList[vertex2].filter(
            v => v !== vertex1
        );
        return g;
    } 

    removeVertex(vertex) {
        while (this.adjacencyList[vertex].length) {
            const adjacencyVertex = this.adjacencyList[vertex].pop()
            this.removeEdge(vertex, adjacencyVertex);
        }
        delete this.adjacencyList[vertex]
        return g;
    }

    depthFirstRecursive(start) {
        const result = [];
        const visited = {};
        const adjacencyList = this.adjacencyList;

        (function dfs(vertex) {
            if(!vertex) return null;
            visited[vertex] = true;
            result.push(vertex);
            adjacencyList[vertex].forEach(neighbor => {
                if(!visited[neighbor]) {
                    return dfs(neighbor)
                }
            });
        })(start);
        return result;
    }

    depthFirstIterative(start) {
        const stack = [start];
        const result = [];
        const visited = {};
        let currentVertex;

        visited[start] = true;
        while(stack.length) {
            console.log(stack);
            currentVertex = stack.pop();
            result.push(currentVertex);

            this.adjacencyList[currentVertex].forEach(neighbor => {
                if(!visited[neighbor]) {
                    visited[neighbor] = true;
                    stack.push(neighbor)
                }
            });
        }
        return result;
    }
    breadthFirst(start) {
        const queue = [start];
        const result = [];
        const visited = {};
        let currentVertex;

        while(queue.length) {
             currentVertex = queue.shift()
             result.push(currentVertex);

             this.adjacencyList[currentVertex].forEach(neighbor => {
                if(!visited[neighbor]) {
                    visited[neighbor] = true;
                    queue.push(neighbor)
                }
             });
        }
        return result;
    }
}

let g =new Graph();
g.addVertex("A")
g.addVertex("B")
g.addVertex("C")
g.addVertex("D")
g.addVertex("E")
g.addVertex("F")

g.addEdge("A","B")
g.addEdge("A","C")
g.addEdge("B","D")
g.addEdge("C","E")
g.addEdge("D","E")
g.addEdge("D","F")
g.addEdge("E","F")


/*
             A
           /   \
          B     C
          |     | 
          D --- E
           \   /
             F
*/

Graph

Aashish Panchal — Thu, 29 Oct 2020 10:34:21 +0000

class Graph {
    constructor() {
        this.adjacencyList = {};
    }

 // Add Value in Graph
    addVertex(vertex) {
        if(!this.adjacencyList[vertex]) {
          this.adjacencyList[vertex] = [];  
        } 
        console.log(` -> ${vertex} -> Added successfully `)
        return g;
    }
 // Add Edge-Array in Graph   
 // EXAMPLE.. -> g.addEdge("Rajkot", "Ahmedabad")
    addEdge(v1,v2) {
        this.adjacencyList[v1].push(v2);
        this.adjacencyList[v2].push(v1);
        console.log(` -> ${v1} or ${v2} -> Edge-Array Added successfully `)
        return g;
    }

 // Remove Value in Graph
    removeEdge(vertex1,vertex2) {
        this.adjacencyList[vertex1] = this.adjacencyList[vertex1].filter(
            v => v !== vertex2
        );
        this.adjacencyList[vertex2] = this.adjacencyList[vertex2].filter(
            v => v !== vertex1
        );

        console.log(`-> ${vertex1} or ${vertex2} -> Edge-Array Deleted successfully`)
        return g;
    }

 // Remove a Vertex in Graph
    removeVertex(vertex) {
        while (this.adjacencyList[vertex].length) {
            const adjacencyVertex = this.adjacencyList[vertex].pop()
            this.removeEdge(vertex, adjacencyVertex);
        }
        delete this.adjacencyList[vertex]
        console.log(`-> ${vertex} -> Deleted successfully `)
        return g;
    }
}

let g =new Graph();
g.addVertex("Rajkot");  
g.addVertex("Ahmedabad");
g.addVertex("Morbi");
g.addEdge("Morbi", "Ahmedabad")
g.addEdge("Rajkot", "Morbi")

Hash Tables

Aashish Panchal — Tue, 27 Oct 2020 10:18:30 +0000

class HashTable {
  constructor(size=53){
    this.keyMap = new Array(size);
  }

  _hash(key) {
    let total = 0;
    let WEIRD_PRIME = 31;
    for (let i = 0; i < Math.min(key.length, 100); i++) {
      let char = key[i];
      let value = char.charCodeAt(0) - 96
      total = (total * WEIRD_PRIME + value) % this.keyMap.length;
    }
    return total;
  }

  // Add a Value
  set(key, value) {
    let index = this._hash(key);
    if(!this.keyMap[index]) {
      this.keyMap[index] = [];
    }
    this.keyMap[index].push([key, value]);
    console.log(` ${key} or ${value} ->> is added successfully 👍👍`)
    return ht;
  }

  // Find a value 
  get(key) {
    let index = this._hash(key);
    if(this.keyMap[index]) {
      for(let i = 0; i < this.keyMap[index].length; i++) {
        if(this.keyMap[index][i][0] === key) {
          return this.keyMap[index][i][1]
        }
      }
    }
    return undefined;
  }

  // Show all Keys
  keys() {
    let keysArr = [];
    for(let i = 0; i <this.keyMap.length; i++) {
      if(this.keyMap[i]) {
        for( let j = 0; j < this.keyMap[i].length; j++) {
          if(!keysArr.includes(this.keyMap[i][j][0])) { 
            keysArr.push(this.keyMap[i][j][0])
          }
        }
      }
    }
    console.log(` Your Keys is -> ${keysArr}`);
    return keysArr;
  }

  // Show all Value
  value() {
    let valuesArr = [];
    for(let i = 0; i <this.keyMap.length; i++) {
      if(this.keyMap[i]) {
        for( let j = 0; j < this.keyMap[i].length; j++) {
          if(!valuesArr.includes(this.keyMap[i][j][1])) { 
            valuesArr.push(this.keyMap[i][j][1])
          }
        }
      }
    }
    console.log(` Your Value is -> ${valuesArr}`)
    return valuesArr;
  }
}

let ht = new HashTable(17);
ht.set("java script ", "java")
ht.set("html ", "css")
ht.set("c ", "c++")
ht.value();
ht.keys();



//  ht.keys().forEach(function(key) {
//    console.log(` -> your Key is -> ${ht.get(key)}`);
//  })

//       👆👆 👆 👆 👆 👆 👆 👆 👆

//           👉  OUTPUT 👈

//            -> your Key is -> java
//            -> your Key is -> css 
//            -> your Key is -> c++

Priority Queue

Aashish Panchal — Mon, 26 Oct 2020 09:57:58 +0000

class priorityQueue {
    constructor() {
        this.values = []
    }
    enqueue(val, priority) {
        let newNode = new Node(val, priority)
        this.values.push(newNode);
        this.bubbleUp();
    }

    bubbleUp() {
        let idx = this.values.length - 1;
        const element = this.values[idx];
        while(idx > 0) {
            let parentIdx = Math.floor((idx - 1)/2);
            let parent = this.values[parentIdx];
            if(element.priority <= parent.priority) break;
            this.values[parentIdx] = element;
            this.values[idx] = parent;
            idx = parentIdx;
        }
    }

    dequeue () {
      const min = this.values[0];
      const end = this.values.pop();
          if(this.values.length > 0) {
          this.values[0] = end;
          this.sinkDown()
      }
      return min;
    }
    sinkDown() {
        let idx = 0;
        const length = this.values.length;
        const element = this.values[0];
        while(true) {
            let leftChildIdx = 2 * idx + 1;
            let rightChildIdx = 2 * idx + 2;
            let leftChild,rightChild;
            let swap = null;
            if(leftChildIdx < length) {
                leftChild = this.values[leftChildIdx];
                if(leftChild.priority < element.priority) {
                    swap = leftChildIdx; 
                }
            }
            if(rightChildIdx < length) {
                rightChild = this.values[rightChildIdx];
                if(
                    (swap === null && rightChild.priority < element.priority) 
                                           ||
                    (swap !== null && rightChild.priority < leftChild.priority)
                 ) {
                    swap = rightChildIdx;
                } 
            }

            if(swap === null) break;
            this.values[idx] = this.values[swap]
            this.values[swap] = element;
        }
    }
}

class Node {
    constructor(val, priority) {
        this.val = val;
        this.priority = priority;
    }
}

let ER = new priorityQueue();
ER.enqueue('common cold', 5)
ER.enqueue('gunshot woind', 1)
ER.enqueue('high Fever', 4)
ER.enqueue('broken arm', 2)
ER.enqueue('glass in foot', 3)

BFS and DFS in Binary Search Tree

Aashish Panchal — Thu, 22 Oct 2020 11:36:38 +0000

/* 

                    Example For Binary Search Tree

                              __10__
                            /        \  
                           5         13
                          / \       / \
                         2   7     11 16 
                        / \   \         \
                       1  3   9         18

*/

class Node {
    constructor(value){
        this.length = 0;
        this.value = value;
        this.left = null;
        this.right = null;

    }
}
class BinarySearchTree {
    constructor(){
        this.root = null;
    }


    // Insert a New value in tree 
    insert(value) {
        var newNode = new Node(value);
        if(this.root === null) {
            this.root = newNode;
            return this;
        } else {
            var current = this.root;
            while(true) {
                if(value < current.value) {
                    if(current.left === null) {
                        current.left = newNode;
                        console.log(` ->   ${current.value}  left value -> ${value} added `)
                        return this;    
                    } else {
                        current = current.left;
                    }
                } else if(value > current.value) {
                    if (current.right === null) {
                        current.right = newNode;
                        console.log(` ->   ${current.value}  right value -> ${value} added `)
                        return this;
                    } else {
                        current = current.right;
                    }
                } 
                if(current.value == value) {
                    console.log(` ->  ${value} is  Duplicate value Please Enter Unique Value `)
                    return;
                }
            }
        }
    }

 // find The Value in tree
    find(value) {
           if(this.root === null) return false;
           var current = this.root,
               found = false;
           while(current && !found) {
               if(value < current.value) {
                   current = current.left;
               } else if (value > current.value) {
                   current = current.right;
               } else {
                   console.log(` ->   Founded Successfully -> ${value}`);
                   return current;
               }
           }
           if(!found) console.log(` ->   Not Founded -> ${value}`);
           return current;
    }

 // Same as no find
    contains(value) {
       if(this.root === null) return false;
       var current = this.root,
           found = false;
       while(current && !found) {
           if(value < current.value) {
               current = current.left;
           } else if (value > current.value) {
               current = current.right;
           } else {
               console.log(` ->   Founded Successfully -> ${value}`);
               return current;
           }
       }
       if(!found) console.log(` ->   Not Founded -> ${value}`);
       return current;
   }


    /* 

                        Example For BREADTH FIRST SEARCH List

                  first ->        __10__
                                /        \  
                 second ->     6         15
                              / \         \
                 third ->    3   8        20

    */
   BFS() {
       var node = this.root,
           data = [],
          queue = [];
       queue.push(node);

       while(queue.length) {
          node = queue.shift()
          data.push(node.value);
          if(node.left) queue.push(node.left);
          if(node.right) queue.push(node.right);
       }
       console.log(` ->   BFS -> BREADTH FIRST SEARCH List is -> ${data}`);
       return data;
   }


    /* 

                        Example For DEPTH FIRST SEARCH List in PreOrder

                 Third ->         __10__
                                /        \  
                 Second ->     6         15
                              / \         \
                First ->     3   8        20

    */
   DSFPreOrder(){
       var data = [];
       function traverse(node) {
           data.push(node.value);
          if(node.left) traverse(node.left);
          if(node.right) traverse(node.right);
       }
       traverse(this.root);
       console.log(` ->   DSF -> Pre Order List is -> ${data}`)
       return data
   }

    /* 

                        Example For DEPTH FIRST SEARCH List in PostOrder

                      sixth ->    __10__
                                /        \  
                     Third ->  6         15 <- Fiveth
                              / \         \
                    First -> 3   8 <-     20 <- Fourth
                                    |
                            Second _|

    */
    DSFPostOrder() {
        var data = [];
        function traverse(node) {
          if(node.left) traverse(node.left);
          if(node.right) traverse(node.right);
          data.push(node.value);
        }
        traverse(this.root);
       console.log(` ->   DSF -> Post Order List is -> ${data}`)
        return data;
    }

    DSFinOrder() {
        var data = [];
        function traverse(node) {
          node.left && traverse(node.left);
          data.push(node.value);
          node.right && traverse(node.right);
        }
        traverse(this.root);
       console.log(` ->   DSF -> In Order List is -> ${data}`)
        return data;
    }
}

var tree = new BinarySearchTree();
tree.insert(10)
tree.insert(6)
tree.insert(15)
tree.insert(3)
tree.insert(8)
tree.insert(20)
console.log(" ");
tree.BFS()
tree.DSFPreOrder()
tree.DSFPostOrder()
tree.DSFinOrder()

Tree Traversal

Aashish Panchal — Wed, 21 Oct 2020 09:45:26 +0000

class Node {
    constructor(value){
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

class BinarySearchTree {
    constructor(){
        this.root = null;
    }
    insert(value){
        var newNode = new Node(value);
        if(this.root === null){
            this.root = newNode;
            return this;
        }
        var current = this.root;
        while(true){
            if(value === current.value) return undefined;
            if(value < current.value){
                if(current.left === null){
                    current.left = newNode;
                    return this;
                }
                current = current.left;
            } else {
                if(current.right === null){
                    current.right = newNode;
                    return this;
                } 
                current = current.right;
            }
        }
    }
    find(value){
        if(this.root === null) return false;
        var current = this.root,
            found = false;
        while(current && !found){
            if(value < current.value){
                current = current.left;
            } else if(value > current.value){
                current = current.right;
            } else {
                found = true;
            }
        }
        if(!found) return undefined;
        return current;
    }
    contains(value){
        if(this.root === null) return false;
        var current = this.root,
            found = false;
        while(current && !found){
            if(value < current.value){
                current = current.left;
            } else if(value > current.value){
                current = current.right;
            } else {
                return true;
            }
        }
        return false;
    }
    BFS(){
        var node = this.root,
            data = [],
            queue = [];
        queue.push(node);

        while(queue.length){
        node = queue.shift();
        data.push(node.value);
        if(node.left) queue.push(node.left);
        if(node.right) queue.push(node.right);
        }
        return data;
    }
    DFSPreOrder(){
        var data = [];
        function traverse(node){
            data.push(node.value);
            if(node.left) traverse(node.left);
            if(node.right) traverse(node.right);
        }
        traverse(this.root);
        return data;
    }
    DFSPostOrder(){
        var data = [];
        function traverse(node){
            if(node.left) traverse(node.left);
            if(node.right) traverse(node.right);
            data.push(node.value);
        }
        traverse(this.root);
        return data;
    }
    DFSInOrder(){
        var data = [];
        function traverse(node){
            if(node.left) traverse(node.left);
            data.push(node.value);
            if(node.right) traverse(node.right);
        }
        traverse(this.root);
        return data;
    }
}


var tree = new BinarySearchTree();
tree.insert(10);
tree.insert(6);
tree.insert(15);
tree.insert(3);
tree.insert(8);
tree.insert(20);
tree.DFSPreOrder();
tree.DFSPostOrder();
tree.DFSInOrder();

Binary Search Trees

Aashish Panchal — Wed, 21 Oct 2020 09:20:32 +0000

/* 

                    Example For Binary Search Tree
                              __10__
                            /        \  
                           5         13
                          / \       / \
                         2   7     11 16 
                        /\   \         \
                       1 3   9         18

*/

class Node {
    constructor(value){
        this.value = value;
        this.left = null;
        this.right = null;

    }
}
class BinarySearchTree {
    constructor(){
        this.root = null;
    }


    // Insert a New value in tree 
    insert(value) {
        var newNode = new Node(value);
        if(this.root === null) {
            this.root = newNode;
            return this;
        } else {
            var current = this.root;
            while(true) {
                if(value < current.value) {
                    if(current.left === null) {
                        current.left = newNode;
                        console.log(` ->   ${current.value}  left value -> ${value} added `)
                        return this;    
                    } else {
                        current = current.left;
                    }
                } else if(value > current.value) {
                    if (current.right === null) {
                        current.right = newNode;
                        console.log(` ->   ${current.value}  right value -> ${value} added `)
                        return this;
                    } else {
                        current = current.right;
                    }
                } 
                if(current.value == value) {
                    console.log(` ->  ${value} is  Duplicate value Please Enter Unique Value `)
                    return;
                }
            }
        }
    }

 // find The Value in tree
    find(value) {
           if(this.root === null) return false;
           var current = this.root,
               found = false;
           while(current && !found) {
               if(value < current.value) {
                   current = current.left;
               } else if (value > current.value) {
                   current = current.right;
               } else {
                   console.log(`Founded Successfully -> ${value}`);
                   return current;
               }
           }
           if(!found) console.log(`Not Founded -> ${value}`);
           return current;
    }

 // Same as on find
    contains(value) {
       if(this.root === null) return false;
       var current = this.root,
           found = false;
       while(current && !found) {
           if(value < current.value) {
               current = current.left;
           } else if (value > current.value) {
               current = current.right;
           } else {
               console.log(`Founded Successfully -> ${value}`);
               return current;
           }
       }
       if(!found) console.log(`Not Founded -> ${value}`);
       return current;
}
}

var tree = new BinarySearchTree();
tree.insert(10)
tree.insert(5)
tree.insert(13)
tree.insert(2)
tree.insert(7)
tree.insert(11)
tree.insert(16)