PYTHON

tree breadth first search

const breadthFirstTraversal = (root) => {
  if (root === null) return [];

  const result = [];
  const queue = [root];

  while (queue.length > 0) {
    const current = queue.shift();
    result.push(current.data);
    if (current.left) queue.push(current.left);
    if (current.right) queue.push(current.right);
  }
  return result;
};

Breadth First Search

graph = {
  '5' : ['3','7'],
  '3' : ['2', '4'],
  '7' : ['8'],
  '2' : [],
  '4' : ['8'],
  '8' : []
}

visited = [] # List for visited nodes.
queue = []     #Initialize a queue

def bfs(visited, graph, node): #function for BFS
  visited.append(node)
  queue.append(node)

  while queue:          # Creating loop to visit each node
    m = queue.pop(0) 
    print (m, end = " ") 

    for neighbour in graph[m]:
      if neighbour not in visited:
        visited.append(neighbour)
        queue.append(neighbour)

# Driver Code
print("Following is the Breadth-First Search")
bfs(visited, graph, '5')    # function calling

Breath First Search

// Java Breath First Search
// ------------------------

import java.util.*;                

public class BreathFirstSearch {

    int V;
    ArrayList<Integer> adj[];

    BreathFirstSearch(int noofvertex) {
        V = noofvertex;
        adj = new ArrayList[noofvertex];
        for (int i = 0; i < noofvertex; i++) {
            adj[i] = new ArrayList<>();
        }
    }

    void edge(int x, int y) {
        adj[x].add(y);
    }

    void bfs(int sourcevertex) {
        boolean[] visited = new boolean[V];
        ArrayList<Integer> a1 = new ArrayList<Integer>();
        visited[sourcevertex] = true;
        a1.add(sourcevertex);
        while (!a1.isEmpty()) {
            sourcevertex = a1.remove(0);
            System.out.print(sourcevertex + "");
            Iterator i = adj[sourcevertex].iterator();
            while (i.hasNext()) {
                int n = (int)  i.next();
                if (!visited[n]) {
                    visited[n] = true;
                    a1.add(n);
                }
            }
        }

    }

    public static void main(String[] args) {
        BreathFirstSearch g1 = new BreathFirstSearch(6);
        g1.edge(0, 1);
        g1.edge(0, 2);
        g1.edge(0, 5);
        g1.edge(1, 0);
        g1.edge(1, 2);
        g1.edge(2, 0);
        g1.edge(2, 1);
        g1.edge(2, 3);
        g1.edge(2, 4);
        g1.edge(3, 2);
        g1.edge(4, 2);
        g1.edge(4, 5);
        g1.edge(5, 0);

        g1.bfs(0);
    }
}

breadth first search

BFS-> uses queue
DFS-> uses stack or recursion (less code)
NOTE: same idea algo wise for both

IDEA:
1 declare the DS(if bfs-DS will be queue,if dfs-stack)
2 push the start node to DS
3 when you push you mark it as visited
4 until the DS is not empty run a loop
5 inside loop pop the DS(deque for queue or pop for stack) and save it in a new object actual
6 loop through the neighbors of actual
7 if the current neighbor n is not visited
8 then push n in DS
9 mark n as visited in the next line.

breadth First

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


  breadthFirst() {
let result = [];
let queue=[];
let current = this.root;
queue.push(current);

    while(queue.length){
current=queue.shift();
result.push(current.data);
if(current.left) queue.push(current.left);
if(current.right) queue.push(current.right);
    }
return result;
  }
}

//if you find this answer is useful ,
//upvote ⇑⇑ , so can the others benefit also . @mohammad alshraideh ( ͡~ ͜ʖ ͡°)

breadth first search tip

remember for breadth first searches, you are putting the vertex of your graph into a queue and that determines the order they are travelled