Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/rajsoni03/competitive-programming-training

Competitive Programming Training including Data Structure and Algorithms
https://github.com/rajsoni03/competitive-programming-training

competitive-programming cplusplus data-structures stl-algorithms stl-containers

Last synced: about 1 month ago
JSON representation

Competitive Programming Training including Data Structure and Algorithms

Awesome Lists containing this project

README 

        
# Competitive-Programming-Training



`Prerequisite` - Basic knowledge of C++ ([C++ Training Codes](https://github.com/Rajsoni03/CPlusPlus-Training)) 



`CPP Docs` - [Link](https://www.cplusplus.com/)



- DSA Sheets

	- [Love Babbar](https://www.geeksforgeeks.org/dsa-sheet-by-love-babbar/)

	- [Striver](https://takeuforward.org/interviews/strivers-sde-sheet-top-coding-interview-problems/)

	- [Fraz](https://www.codingninjas.com/codestudio/problem-lists/mohammad-fraz-dsa-sheet-problems)






## Day 1 - Array ([PDF](/PDF_Notes/Day-1.pdf))



- Asymptotic Notation

- Big O

- Time Complexity

- Space Complexity 

- Basic Notations

	- O(1) - Constant

	- O(log N) - Logarithmic

	- O(N) - Linear

	- O(N log N) - Linearithmic

	- O(N2) - Quadratic

	- O(N3) - Cubic

	- O(2N) - Exponential 

	- O(NN) - Exponential

- Basics of Array

- Reverse the Array



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ |:--------:| --------:|

|  1   | Reverse the array | [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/reverse-an-array/0) | [solution](Solutions/sol_001.md) |

|  2   | Reverse String | [Leetcode](https://leetcode.com/problems/reverse-string/) | [solution](Solutions/sol_002.md) |

|  3   | Find the maximum and minimum element in an array | [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/find-minimum-and-maximum-element-in-an-array4428/1) | [solution](Solutions/sol_003.md) |

|  4   | Complete Sum | [CodeStudio](https://www.codingninjas.com/codestudio/problems/complete-sum_3161880) | [solution](Solutions/sol_004.md) |

 



## Day 2 - STL ([PDF](/PDF_Notes/Day-2.pdf))



- Standard Template Library (STL)

	- Container

		- `array`

		- `vector`

		- `list`

		- `stack`

		- `queue`

		- `set`

		- `map`

	- Iterator

		- `begin()`

		- `end()`

		- `rbegin()`

		- `rend()`

	- Algorithm

		- `swap()`

		- `min()` & `max()`

		- `min_element()` & `max_element()`

		- `minmax()` & `minmax_element()` 

		- `sort()`

		- `find()`

		- `search()`

- Implement template array class 



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ |:--------:| --------:|

|  5   | Final Value of Variable After Performing Operations | [Leetcode](https://leetcode.com/problems/final-value-of-variable-after-performing-operations/) | [solution](Solutions/sol_005.md) |

|  6   | Maximum Number of Words Found in Sentences | [Leetcode](https://leetcode.com/problems/maximum-number-of-words-found-in-sentences/) | [solution](Solutions/sol_006.md) |

|  7   | Shuffle String | [Leetcode](https://leetcode.com/problems/shuffle-string/) | [solution](Solutions/sol_007.md) |

|  8   | Check If It Is a Straight Line | [Leetcode](https://leetcode.com/problems/check-if-it-is-a-straight-line/) | [solution](Solutions/sol_008.md) |



## Day 3 - Vector ([PDF](/PDF_Notes/Day-3.pdf))



- STL vector

	- Constructor

		- `vector v;`

		- `vector v(size);`

		- `vector v(size, fill_value);`

	- Methods

		- Iterators

			- begin()

			- end()

		- Capacity

			- size()

			- capacity()

			- empty()

		- Modifiers and Access

			- operator[]

			- push_back()

			- pop_back()

			- insert()

			- swap()



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  9   | Value equal to index value | [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/value-equal-to-index-value1330/1) | [solution](Solutions/sol_009.md) |

|  10  | Sort an array of 0s, 1s and 2s | [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/sort-an-array-of-0s-1s-and-2s4231/1#) | [solution](Solutions/sol_010.md) |

|  11  | Cyclically rotate an array by one | [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/cyclically-rotate-an-array-by-one2614/1/) | [solution](Solutions/sol_011.md) |

|  12  | Palindromic Array | [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/palindromic-array-1587115620/1) | [solution](Solutions/sol_012.md) |



## Day 4 - Pair ([PDF](/PDF_Notes/Day-4.pdf))



- Implement template Pair class

- STL pair



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  13  | Move all negative elements to end | [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/move-all-negative-elements-to-end1813/1) | [solution](Solutions/sol_013.md) |

|  14   | Count Items Matching a Rule | [LeetCode](https://leetcode.com/problems/count-items-matching-a-rule/) | [solution](Solutions/sol_014.md) |

|  15   | Kth Missing Positive Number | [LeetCode](https://leetcode.com/problems/kth-missing-positive-number/) | [solution](Solutions/sol_015.md) |

|  16   | Plus One | [LeetCode](https://leetcode.com/problems/plus-one/) | [solution](Solutions/sol_016.md) |



## Day 5 - String & Numbers ([PDF](/PDF_Notes/Day-5.pdf))



- Reverse string

- Reverse integer number

- String palindrome

- Integer palindrome

- Fibonacci series with recursion

- Fibonacci series with loop



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  17   | Number of Good Pairs | [LeetCode](https://leetcode.com/problems/number-of-good-pairs/) | [solution](Solutions/sol_017.md) |

|  18   | How Many Numbers Are Smaller Than the Current Number | [LeetCode](https://leetcode.com/problems/how-many-numbers-are-smaller-than-the-current-number/) | [solution](Solutions/sol_018.md) |

|  19   | Palindrome Number | [LeetCode](https://leetcode.com/problems/palindrome-number/) | [solution](Solutions/sol_019.md) |

|  20   | Fibonacci Number | [LeetCode](https://leetcode.com/problems/fibonacci-number/) | [solution](Solutions/sol_020.md) |

|  21   | Reverse Integer | [LeetCode](https://leetcode.com/problems/reverse-integer/) | [solution](Solutions/sol_021.md) |



## Day 6 - Bit Manipulation ([PDF](/PDF_Notes/Day-6.pdf))



- Bitwise Operators

	- `|` Bitwise OR operator 

		- used to set bit to 1

	- `&` Bitwise AND operator 

		- used to set bit to 0

		- used to get nth bit

	- `~` Bitwise NOT operator

		- used to inverts the bits 

	- `<<` Bitwise left shift operator

	- `>>` Bitwise right shift operator



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  22  | Number of 1 Bits | [Leetcode](https://leetcode.com/problems/number-of-1-bits/) [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/set-bits0143/1) | [solution](Solutions/sol_022.md) |

|  23  | Number of Steps to Reduce a Number to Zero | [LeetCode](https://leetcode.com/problems/number-of-steps-to-reduce-a-number-to-zero/) | [solution](Solutions/sol_023.md) |

|  24  | Minimum Bit Flips to Convert Number | [LeetCode](https://leetcode.com/problems/minimum-bit-flips-to-convert-number/) | [solution](Solutions/sol_024.md) |

|  25  | Hamming Distance | [LeetCode](https://leetcode.com/problems/hamming-distance/) | [solution](Solutions/sol_025.md) |

|  26  | Complement of Base 10 Integer | [LeetCode](https://leetcode.com/problems/complement-of-base-10-integer/) | [solution](Solutions/sol_026.md) |

|  27  | Binary Gap | [LeetCode](https://leetcode.com/problems/binary-gap/) | [solution](Solutions/sol_027.md) |

|  28  | Reverse Bits | [LeetCode](https://leetcode.com/problems/reverse-bits/) | [solution](Solutions/sol_028.md) |



## Day 7 - Bit Manipulation ([PDF](/PDF_Notes/Day-7.pdf))



- `^` XOR Operator

	- data encryption

	- data decryption

- find missing number from 1 - n range

- find non repeating number

- add 2 numbers without arithmetic operators



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  29  | Missing Number | [LeetCode](https://leetcode.com/problems/missing-number/) | [solution](Solutions/sol_029.md) |

|  30  | Find the Duplicate Number | [LeetCode](https://leetcode.com/problems/find-the-duplicate-number/) | [solution](Solutions/sol_030.md) |

|  31  | XOR Operation in an Array | [LeetCode](https://leetcode.com/problems/xor-operation-in-an-array/) | [solution](Solutions/sol_031.md) |

|  32  | Decode XORed Array | [LeetCode](https://leetcode.com/problems/decode-xored-array/) | [solution](Solutions/sol_032.md) |

|  33  | Single Number | [LeetCode](https://leetcode.com/problems/single-number/) | [solution](Solutions/sol_033.md) |

|  34  | Counting Bits | [LeetCode](https://leetcode.com/problems/counting-bits/) | [solution](Solutions/sol_034.md) |

|  35  | Count total set bits | [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/count-total-set-bits-1587115620/1) | [solution](Solutions/sol_035.md) |

|  36  | Power of Two | [LeetCode](https://leetcode.com/problems/counting-bits/) / [GeeksForGeeks](https://www.geeksforgeeks.org/program-to-find-whether-a-given-number-is-power-of-2/) | [solution](Solutions/sol_036.md) |

|  37  | Bit Difference | [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/bit-difference-1587115620/1#) | [solution](Solutions/sol_037.md) |



## Day 8 - Bit Manipulation ([PDF](/PDF_Notes/Day-8.pdf))



- `(num & 1) == 0` - Check if the integer is even

- `x = x & (1<2)

	- Space - O(1)

	- Non Stable

	- Iterative

	- Inplace 

```cpp

void selectionSort(int arr[], int n){

	int min_value, min_index;



	for (int i = 0; i < n-1; i++){  

		min_value = arr[i];

		min_index = i;            



		for (int j = i+1; j < n; j++){

			if (arr[j] > min_value){

				min_value = arr[j];

				min_index = j;

			}

		}

		swap(arr[i], arr[min_index]);

	}

}

```



## Day 10 - Sorting Algorithms ([PDF](/PDF_Notes/Day-10.pdf))



- Bubble Sort

	- Time - O(N2)

	- Space - O(1)

	- Stable

	- Iterative

	- Inplace 

```cpp

void bubbleSort(int arr[], int n){

	for (int i = 0; i < n-1; i++){

		bool flag = true;

		for (int j = 0; j < n-1; j++){

			if (arr[j] > arr[j+1]){

				swap(arr[j],arr[j+1]);

				flag = false;

			}

		}

		if (flag) break;

	}

}

```

- Insertion Sort

	- Time - O(N2)

	- Space - O(1)

	- Stable

	- Iterative

	- Inplace 

```cpp

void insertionSort(int arr[], int n){

	int val, j;



	for (int i = 1; i < n; i++){

		val = arr[i];

		j = i;

		while(j>0 && arr[j-1] > val){

			arr[j] = arr[j-1];

			j--;

		}

		arr[j] = val;

	}

}

```



## Day 11 - Sorting Algorithms ([PDF](/PDF_Notes/Day-11.pdf))



- Merge 2 Sorted Array

- Merge Sort

	- Time - O(N log N)

	- Space - O(n)

	- Stable

	- Recursive

	- Divide and conquer

```cpp

void mergeSort(int arr[], int n){

	if (n < 2) return;

	int mid = n/2;

	int left[mid];

	int right[n - mid];

	for (int i = 0; i < mid; i++){

		left[i] = arr[i];

	}

	for (int i = mid; i < n; i++){

		right[i-mid] = arr[i];

	}

	mergeSort(left, mid);

	mergeSort(right, n-mid);

	margeArray(left, right, arr, mid, n-mid);

}

```



## Day 12 - Sorting Algorithms ([PDF](/PDF_Notes/Day-12.pdf))



- Quick Sort

	- Time - Avg. - O(N log N), Worse - O(N2)

	- Space - O(n)

	- Stable

	- Recursive

	- Divide and conquer

	

```cpp

int partition(int arr[], int start, int end){

	int pivot = arr[end];

	int j = start;

	for (int i = start; i < end; i++){

		if (arr[i] <= pivot){

			swap(arr[i], arr[j]);

			j++;

		}

	}

	swap(arr[end], arr[j]);

	return j;

}



void quickSort(int arr[], int start, int end){

	if (start >= end) return;               // base condition

	int pivot = partition(arr, start, end);

	quickSort(arr, start, pivot-1);         // left arr

	quickSort(arr, pivot+1, end);           // right arr

}

```



## Day 13 - Linked List ([PDF](/PDF_Notes/Day-13.pdf))



- Implement Singly LinkedList

- Implement Node Class/Struct

- Implement functions

	- `push_front()`

	- `push_back()`

	- `display()`

	- `size()`

	- `last()`



```cpp

class Node{

public:

	int data;

	Node* next;

	Node(int data = 0, Node* next = nullptr) : data(data), next(next){}

}

```



## Day 14 - Linked List ([PDF](/PDF_Notes/Day-14.pdf))



- Implement Functions

	- `pop_front()`

	- `pop_back()`

	- `search()`

	- `at()`



## Day 15 - Linked List ([PDF](/PDF_Notes/Day-15.pdf))



- insert array element to list at back in O(N) time

- find mid element 

	- by using length (2 iteration)

	- by using 2 (slow & fast) pointers (single iteration)

- find ith element from last	

	- by using length (2 iteration)

	- by using 2 (slow & fast) pointers (single iteration)



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  41  | Middle of the Linked List | [LeetCode](https://leetcode.com/problems/middle-of-the-linked-list) | [solution](Solutions/sol_041.md) |

|  42  | Convert Binary Number in a Linked List to Integer | [LeetCode](https://leetcode.com/problems/convert-binary-number-in-a-linked-list-to-integer) | [solution](Solutions/sol_042.md) |

|  43  | Delete Node in a Linked List | [LeetCode](https://leetcode.com/problems/delete-node-in-a-linked-list/) | [solution](Solutions/sol_043.md) |

|  44  | Remove Duplicates from Sorted List | [LeetCode](https://leetcode.com/problems/remove-duplicates-from-sorted-list/) | [solution](Solutions/sol_044.md) |



## Day 16 - Linked List ([PDF](/PDF_Notes/Day-16.pdf))



- Reverse a Linked List

	- by creating new list

	- by stack

	- by 3 pointers 

	- by push front same node



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  45  | Remove Linked List Elements | [LeetCode](https://leetcode.com/problems/remove-linked-list-elements/) | [solution](Solutions/sol_045.md) |

|  46  | Reverse Linked List | [LeetCode](https://leetcode.com/problems/reverse-linked-list) | [solution](Solutions/sol_046.md) |

|  47  | Reverse Linked List II | [LeetCode](https://leetcode.com/problems/reverse-linked-list-ii/) | [solution](Solutions/sol_047.md) |



## Day 17 - Linked List ([PDF](/PDF_Notes/Day-17.pdf))



- Loop Detection 

	- using map / set

	- is cycle found



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  48  | Linked List Cycle | [LeetCode](https://leetcode.com/problems/linked-list-cycle/) | [solution](Solutions/sol_048.md) |



## Day 18 - Linked List ([PDF](/PDF_Notes/Day-18.pdf))



- Loop Detection 

	- return cycle node

	- remove cycle



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  49  | Linked List Cycle II | [LeetCode](https://leetcode.com/problems/linked-list-cycle-ii/) | [solution](Solutions/sol_049.md) |



## Day 19 - Linked List ([PDF](/PDF_Notes/Day-18.pdf))



- Check Palindrome in Linked List

- Reorder Linked List



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  50  | Palindrome Linked List | [LeetCode](https://leetcode.com/problems/palindrome-linked-list/) | [solution](Solutions/sol_050.md) |

|  51  | Reorder List | [LeetCode](https://leetcode.com/problems/reorder-list/) | [solution](Solutions/sol_051.md) |



## Day 20 - Linked List ([PDF](/PDF_Notes/Day-20.pdf))



- Merge Two Sorted Lists

- Add Two Numbers



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  52  | Merge Two Sorted Lists | [LeetCode](https://leetcode.com/problems/merge-two-sorted-lists/) | [solution](Solutions/sol_052.md) |

|  53  | Add Two Numbers | [LeetCode](https://leetcode.com/problems/add-two-numbers/) | [solution](Solutions/sol_053.md) |



## Day 21 - Stack ([PDF](/PDF_Notes/Day-21.pdf))



- Stack Interface

	- `push()`

	- `pop()`

	- `top()`

	- `size()`

	- `empty()`

- Stack Implementation

	- array based stack

	- linked list based stack

- Template Implementation of stack



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  54  | Implement Stack using Array | [Work@Tech](https://workat.tech/problem-solving/practice/implement-stack-array) | [solution](Solutions/sol_054.md) |

|  55  | Implement Stack using Linked List | [Work@Tech](https://workat.tech/problem-solving/practice/implement-stack-linked-list) | [solution](Solutions/sol_055.md) |

|  56  | Valid Parentheses | [LeetCode](https://leetcode.com/problems/valid-parentheses/), [Work@Tech](https://workat.tech/problem-solving/practice/balanced-parentheses) | [solution](Solutions/sol_056.md) |



## Day 22 - Queue ([PDF](/PDF_Notes/Day-22.pdf))



- Queue Interface

	- `push()`

	- `pop()`

	- `top()`

	- `size()`

	- `empty()`

- Queue Implementation

	- array based queue

	- linked list based queue

- Template Implementation of queue



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  57  | Implement Queue using Array | [Work@Tech](https://workat.tech/problem-solving/practice/implement-queue-array) | [solution](Solutions/sol_057.md) |

|  58  | Implement Queue using Linked List | [Work@Tech](https://workat.tech/problem-solving/practice/implement-queue-linked-list) | [solution](Solutions/sol_058.md) |

|  59  | Implement Queue using Stacks | [LeetCode](https://leetcode.com/problems/implement-queue-using-stacks/), [Work@Tech](https://workat.tech/problem-solving/practice/implement-queue-using-stacks) | [solution](Solutions/sol_059.md) |

|  60  | Implement Stack using Queues | [LeetCode](https://leetcode.com/problems/implement-stack-using-queues/), [Work@Tech](https://workat.tech/problem-solving/practice/implement-stack-using-queues) | [solution](Solutions/sol_060.md) |



## Day 23 - Stack & Queue Problems ([PDF](/PDF_Notes/Day-23.pdf))



- Min Stack

- Next Greater Element



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  61  | Implement Min Stack | [LeetCode](https://leetcode.com/problems/min-stack/), [Work@Tech](https://workat.tech/problem-solving/practice/min-stack) | [solution](Solutions/sol_061.md) |

|  62  | Next Greater Element | [Work@Tech](https://workat.tech/problem-solving/practice/next-greater-element) | [solution](Solutions/sol_062.md) |

|  63  | Next Greater Element II | [LeetCode](https://leetcode.com/problems/next-greater-element-ii/) | [solution](Solutions/sol_063.md) |



## Day 24 - Stack & Queue Problems ([PDF](/PDF_Notes/Day-24.pdf))



- Tower of Hanoi

- Expression resolution 

	- Infix

	- Prefix

	- Postfix 



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  64  | Tower of Hanoi | [GeeksForGeeks](https://practice.geeksforgeeks.org/problems/tower-of-hanoi-1587115621/1) | [solution](Solutions/sol_064.md) |

|  65  | Postfix Notation | [Work@Tech](https://workat.tech/problem-solving/practice/evaluate-reverse-polish-notation) | [solution](Solutions/sol_065.md) |



## Day 25 - Stack & Queue Problems ([PDF](/PDF_Notes/Day-25.pdf))



- Infix to Postfix Conversion

- Simplify Directory Path



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  66  | Simplify Directory Path | [Work@Tech](https://workat.tech/problem-solving/practice/simplify-directory-path) | [solution](Solutions/sol_066.md) | 

|  67  | Sliding Window Maximum | [Work@Tech](https://workat.tech/problem-solving/practice/sliding-window-maximum), [LeetCode](https://leetcode.com/problems/sliding-window-maximum/) | [solution](Solutions/sol_067.md) | 



## Day 26 - Binary Tree ([PDF](/PDF_Notes/Day-26.pdf))



- Binary Tree

- Structure of Binary Tree

- Traversal

	- Inorder

	- Preorder

	- Postorder

- Number of Nodes in Tree

- Max Height of Tree



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  68  | Binary Tree Inorder Traversal | [Work@Tech](https://workat.tech/problem-solving/practice/binary-tree-inorder-traversal) | [solution](Solutions/sol_068.md) | 

|  69  | Binary Tree Preorder Traversal | [Work@Tech](https://workat.tech/problem-solving/practice/binary-tree-preorder-traversal) | [solution](Solutions/sol_069.md) | 

|  70  | Binary Tree Postorder Traversal | [Work@Tech](https://workat.tech/problem-solving/practice/binary-tree-postorder-traversal) | [solution](Solutions/sol_070.md) | 

|  71  | Maximum Depth of Binary Tree | [Work@Tech](https://workat.tech/problem-solving/practice/maximum-depth-of-binary-tree) | [solution](Solutions/sol_071.md) | 



## Day 27 - Binary Tree ([PDF](/PDF_Notes/Day-27.pdf))



- Level Order Traversal

- Iterative Traversal

	- Inorder

	- Preorder

	- Postorder

- Identical Binary Trees

- Symmetric Binary Tree

- Invert Binary Tree

- Diameter of Binary Tree



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  72  | Level Order of Binary Tree | [Work@Tech](https://workat.tech/problem-solving/practice/level-order-binary-tree) | [solution](Solutions/sol_072.md) | 

|  73  | Identical Binary Trees | [Work@Tech](https://workat.tech/problem-solving/practice/identical-binary-trees) | [solution](Solutions/sol_073.md) |

|  74  | Symmetric Binary Tree | [Work@Tech](https://workat.tech/problem-solving/practice/symmetric-binary-tree) | [solution](Solutions/sol_074.md) |

|  75  | Invert Binary Tree | [Work@Tech](https://workat.tech/problem-solving/practice/invert-binary-tree) | [solution](Solutions/sol_075.md) |

|  76  | Diameter of Binary Tree | [Work@Tech](https://workat.tech/problem-solving/practice/diameter-of-binary-tree) | [solution](Solutions/sol_076.md) |



## Day 28 - Binary Tree ([PDF](/PDF_Notes/Day-28.pdf))



- Print each levels 

- print ith level of tree

- zig-zeg order traversal

	- using stack and queue

	- using deque



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  77  | Binary Tree Zigzag Level Order Traversal | [Work@Tech](https://workat.tech/problem-solving/practice/zigzag-level-order-traversal) | [solution](Solutions/sol_077.md) | 



## Day 29 - Binary Tree ([PDF](/PDF_Notes/Day-29.pdf))



- Left View of Tree

- Right View of Tree

- Build Tree [link](https://www.geeksforgeeks.org/construct-complete-binary-tree-given-array/)



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  78  | Left View of Binary Tree | [Work@Tech](https://workat.tech/problem-solving/practice/left-view-binary-tree) | [solution](Solutions/sol_078.md) | 

|  79  | Right View of Binary Tree | [Work@Tech](https://workat.tech/problem-solving/practice/right-view-binary-tree) | [solution](Solutions/sol_079.md) | 



## Day 30 - Binary Tree ([PDF](/PDF_Notes/Day-30.pdf))



- Top View of Tree

- Bottom View of Tree



|  #   | Problem Name  | Practice | Solution |

| :--: | :------------ | :------: | --------:|

|  80  | Top View of Binary Tree | [Work@Tech](https://workat.tech/problem-solving/practice/top-view-binary-tree) | [solution](Solutions/sol_080.md) | 

|  81  | Bottom View of Binary Tree | [Work@Tech](https://workat.tech/problem-solving/practice/bottom-view-binary-tree) | [solution](Solutions/sol_081.md) |