diff --git a/binary_tree_traversal.java b/binary_tree_traversal.java
new file mode 100644
index 00000000..a4dbe7c7
--- /dev/null
+++ b/binary_tree_traversal.java
@@ -0,0 +1,70 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+
+ // sol 1 - using BFS 
+ // Time Complexity - O(n)
+ //Space Complexity - O(n)
+ /*
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        Queue<TreeNode> q = new LinkedList<>();
+        if(root== null) return result;
+        q.add(root);
+        while(!q.isEmpty()){
+            int size =q.size(); 
+            List<Integer> li = new ArrayList<>();
+            for(int i=0;i<size;i++){
+                TreeNode curr = q.poll();
+                li.add(curr.val);
+                if(curr.left!=null){
+                    q.add(curr.left);
+                }
+                if(curr.right!=null){
+                    q.add(curr.right);
+                }
+            }
+            result.add(li);
+        }
+        return result;
+    }
+}
+*/
+
+//sol-2 Using DFS
+// Time Complexity O(n)
+// Space Complexity O(n)
+class Solution {
+    private List<List<Integer>> result;
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        this.result = new ArrayList<>();
+        dfs(root,0);
+        return result;
+    }
+    private void dfs(TreeNode root, int level){
+        //base
+        if(root==null) return;
+        //logic
+        if(level==result.size()){
+            result.add(new ArrayList<>());
+        }
+        List<Integer> li =result.get(level); 
+        //result.get(level).add(root.val); // if we directly add the value it will be by reference and not val --> ds inside a ds acts like pointer 
+        li.add(root.val);
+        dfs(root.left,level+1);
+        dfs(root.right,level+1);
+    }
+}
\ No newline at end of file
diff --git a/course_schedule.java b/course_schedule.java
new file mode 100644
index 00000000..e591431d
--- /dev/null
+++ b/course_schedule.java
@@ -0,0 +1,48 @@
+// because we deal with neighbour's neighbour's neighbour's ... hence bfs/dfs
+// we are visiting each and everynode Time Complexity: O(V+E)
+// Queue's length is the breath of graph - Space Complexity O(V+E)
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        //Adj List --> HashMap(easy to navigate what are connected values aka neighbours )
+        HashMap<Integer,List<Integer>> map = new HashMap<>();
+        int[] indegrees = new int[numCourses];
+        for(int[] pr:prerequisites){
+            //pr[1] --> Independent course
+            //pr[0] --> Dependent course 
+            // creating indegree array 
+            indegrees[pr[0]]++;
+            map.putIfAbsent(pr[1],new ArrayList<>());
+            map.get(pr[1]).add(pr[0]); // adj list 0--><1,2>
+        }
+        //Get all independent values and add in Queue 
+        Queue<Integer> q = new LinkedList<>(); // For BFS -- FIFO
+        int count=0;
+        for(int i=0;i<numCourses;i++){
+                if(indegrees[i]==0){
+                    q.add(i); // all independent courses 
+                    count++; // counter to mantain how many courses in the queue
+                }
+            }
+            if(q.isEmpty()) return false; // if queue is empty meaning no indep courses 
+            if(count==numCourses) return true; 
+            // if count reaches to all courses indicating all values are indep 
+            // 1. Now we parse through each element in queue 
+            // 2. Get dpenedent values and reduce indegrees - indicating we visited it 
+            // 3. And adding in queue - meaning its indepenent now 
+            while(!q.isEmpty()){
+                int curr = q.poll();
+                List<Integer> dependencies = map.get(curr);
+                if(dependencies!=null){
+                    for(int dep:dependencies){
+                        indegrees[dep]--;
+                        if(indegrees[dep]==0){
+                            q.add(dep);
+                            count++;
+                            if(count==numCourses) return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+    }