
## ...
Background: Archishman saw a massaging neck pillow before.  
## ...

We, 5 guys, were roaming in the ladies and babies section searching for a neck pillow/ neck rest.  
Archishman saw a neck pillow, and wanted to get one.  
We see some neck pillows which **DO NOT VIBRATE**. ```(one also had kitty on it :) )```

At last, without finding any Neck rest, we end up at spencers not expecting to get one there either.  
## But
We found one but it still does not vibrate. But Dhara had to make sure.  
So, He asks the counter lady.  
Dhara: **DOES IT VIBRATE?**  
Counter Lady ```( ͡° ͜ʖ ͡°)```: No.

Defeinitely not a good look. :/  
PS: Some shots from the day below:
![](/assets/20220815_185243.jpg "Overcrowded Junction Mall")
![](/assets/20220815_192918.jpg "Ovals")


76th Independence Day


Dumping some of the pictures from NIT Durgapur here.

![](/assets/20220730_063138.jpg "I'm inside Hall 2 Main")
![](/assets/20220730_112635.jpg "View from Hall 14 Balcony at 10th floor")
![](/assets/20220730_112757.jpg "View from Hall 14 Balcony at 10th floor (other side)")
![](/assets/20220730_113826.jpg)
![](/assets/20220730_211442.jpg)
![](/assets/20220730_112830.jpg)
![](/assets/20220730_113858.jpg)
![](/assets/20220730_211516.jpg)
![](/assets/20220730_213758.jpg)
![](/assets/20220730_215703.jpg)
![](/assets/20220730_222113.jpg)
![](/assets/20220730_222135.jpg, "MS Intern inside")
![](/assets/20220801_084344.jpg)
![](/assets/20220801_084441.jpg)
![](/assets/20220801_085012.jpg)
![](/assets/20220801_085334.jpg)
![](/assets/20220801_164554.jpg)
![](/assets/20220804_171622.jpg)
![](/assets/20220805_190944.jpg)







Random Clicks


When working on college assignments involving tree data structures, one of the most challenging aspects is visualizing the tree in the console. While trees are easy to draw on paper, representing them properly in a terminal requires careful calculation of spacing and positioning. In this post, I'll walk you through the approach I used to print trees with proper level ordering and spacing.

## The Challenge

Trees are hierarchical structures, and displaying them in a 2D console requires us to think about:

- How much horizontal space each node needs
- How to center parent nodes above their children
- How to maintain consistent spacing across levels
- How to handle different tree heights

## Understanding the Spacing Pattern

The key insight is that spacing follows a geometric pattern based on the tree level. For a balanced binary tree:

- **Level 1** (root): 16 spaces from edges
- **Level 2**: 8 spaces between nodes
- **Level 3**: 4 spaces between nodes
- **Level 4**: 2 spaces between nodes
- **Level 5**: 1 space between nodes

Notice the pattern? Each level has half the spacing of the previous level. This makes sense because each level has twice as many nodes as the one above it.

![Representation of Tree DataStructure](/assets/tree.png "Tree DataStructure")

## The Algorithm

Here's the approach I used for printing trees in the console:

### Step 1: Calculate Tree Height

First, we need to know the height of the tree to determine the initial spacing:

```c
int getHeight(Node* root) {
    if (root == NULL) return 0;
    int leftHeight = getHeight(root->left);
    int rightHeight = getHeight(root->right);
    return 1 + (leftHeight > rightHeight ? leftHeight : rightHeight);
}
```

### Step 2: Level Order Traversal with Spacing

We use a queue-based level order traversal, but instead of just printing values, we calculate and print appropriate spacing:

```c
void printTree(Node* root) {
    if (root == NULL) return;
    
    int height = getHeight(root);
    int maxWidth = pow(2, height) - 1;
    
    Queue* queue = createQueue();
    enqueue(queue, root);
    
    int level = 0;
    
    while (!isEmpty(queue)) {
        int levelNodes = pow(2, level);
        int spacing = maxWidth / pow(2, level + 1);
        int betweenSpacing = maxWidth / pow(2, level);
        
        // Print initial spacing
        printSpaces(spacing);
        
        for (int i = 0; i < levelNodes; i++) {
            Node* current = dequeue(queue);
            
            if (current != NULL) {
                printf("%d", current->data);
                enqueue(queue, current->left);
                enqueue(queue, current->right);
            } else {
                printf(" ");
                enqueue(queue, NULL);
                enqueue(queue, NULL);
            }
            
            if (i < levelNodes - 1) {
                printSpaces(betweenSpacing);
            }
        }
        
        printf("\n");
        level++;
        
        if (level >= height) break;
    }
}
```

### Step 3: Helper Function for Spacing

```c
void printSpaces(int count) {
    for (int i = 0; i < count; i++) {
        printf(" ");
    }
}
```

## Practical Example

Let's say we have a Binary Search Tree with values: 50, 30, 70, 20, 40, 60, 80

The output would look like:

```
       50
   30      70
 20  40  60  80
```

The spacing calculation for this 3-level tree:
- Level 1: 7 spaces before root
- Level 2: 3 spaces before first node, 5 spaces between nodes
- Level 3: 1 space before first node, 2 spaces between nodes

## Handling Different Tree Types

### Binary Search Trees

BSTs maintain sorted order, making them perfect for this visualization since the structure naturally shows the ordering property.

### Heaps

For heaps (min-heap or max-heap), this visualization helps verify the heap property at each level. Parent nodes should be smaller (min-heap) or larger (max-heap) than their children.

### General Binary Trees

The same approach works for any binary tree structure, though unbalanced trees might look skewed.

## Optimization Tips

1. **Pre-calculate spacing**: Store spacing values in an array to avoid repeated calculations
2. **Use string buffers**: Build each level as a string before printing to avoid multiple print calls
3. **Handle NULL nodes**: Print spaces for NULL nodes to maintain structure
4. **Limit tree height**: For very tall trees, consider printing only a subset of levels

## Common Pitfalls

- **Off-by-one errors**: Spacing calculations are tricky; test with trees of different heights
- **Integer overflow**: For very tall trees, `pow(2, height)` can overflow
- **Memory leaks**: Remember to free queue memory after printing
- **Character width**: Assumes single-digit values; multi-digit numbers need adjustment

## Conclusion

Visualizing tree structures in the console is a valuable skill for debugging and understanding tree algorithms. While the spacing calculations can be complex, following the geometric pattern of halving spaces at each level provides a clean and readable output.

This approach helped me debug countless tree implementations during my data structures course, and I hope it helps you too. The key is understanding that tree visualization is all about managing spacing proportional to the tree's height and level.

Have you found other creative ways to visualize trees in the console? I'd love to hear about your approaches!

Output of tree based structures like Binary Search Trees or Heaps in terminal with proper spacing and level ordering.

Showing Tree DataStructures in terminal


Over the years, I've collected resources that have been instrumental in my learning journey. Whether you're just starting out or looking to level up your skills, I hope you find these as helpful as I did.

## Getting Started with Programming

If you're new to programming, these resources will give you a solid foundation in C and C++:

- [Neso Academy C Programming](https://www.youtube.com/watch?v=4OGMB4Fhh50&list=PLBlnK6fEyqRhX6r2uhhlubuF5QextdCSM) - Comprehensive video series covering C fundamentals
- [HackerRank C++](https://www.hackerrank.com/domains/cpp?filters%5Bstatus%5D%5B%5D=unsolved&badge_type=cpp) - Practice problems to strengthen your C++ skills
- [HackerRank Problem Solving](https://www.hackerrank.com/domains/data-structures?filters%5Bstatus%5D%5B%5D=unsolved&badge_type=problem-solving) - Build problem-solving intuition with hands-on challenges

## Data Structures & Algorithms

Understanding DSA is crucial for technical interviews and competitive programming. These resources offer both theory and practice:

- [MIT OpenCourseWare - Introduction to Algorithms](https://www.youtube.com/watch?v=HtSuA80QTyo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb) - World-class lectures from MIT professors
- [Pavel Maverin's YouTube Channel](https://www.youtube.com/playlist?list=PLrS21S1jm43igE57Ye_edwds_iL7ZOAG4) - Clear explanations of complex algorithms
- [CodeChef DSA Certification](https://www.codechef.com/certification/data-structures-and-algorithms/prepare) - Structured learning path with certification
- [HackerEarth Tutorials](https://www.hackerearth.com/practice/algorithms/searching/linear-search/tutorial/) - Topic-wise tutorials with practice problems

## Competitive Programming

Ready to compete? These are my go-to references for CP:

- [CP-Algorithms](https://cp-algorithms.com/) - The ultimate reference for competitive programming algorithms (seriously, bookmark this!)
- [TopCoder Tutorials](https://www.topcoder.com/community/competitive-programming/tutorials/) - In-depth articles on advanced techniques and strategies

## Android Development

Building mobile apps? Start here:

- [Android Study Jams](https://developer.android.com/courses/study-jams?utm_source=studyjam&utm_medium=event&utm_campaign=studyjams) - Guided learning paths from Google
- [Android Documentation](https://developer.android.com/docs) - The official docs are your best friend
- [ADB Tutorials](https://www.youtube.com/watch?v=1T9yjDSG3Ho) - Master the Android Debug Bridge

## Machine Learning

Diving into ML? These resources cover both theory and practical implementation:

- [scikit-learn Documentation](https://scikit-learn.org/stable/) - Essential library for ML in Python with excellent tutorials
- [Deep Learning Course - IIT Madras](https://www.youtube.com/watch?v=aPfkYu_qiF4&list=PLyqSpQzTE6M9gCgajvQbc68Hk_JKGBAYT) - Comprehensive lectures by Prof. Mitesh M. Khapra
- [Andrej Karpathy's Channel](https://www.youtube.com/@AndrejKarpathy) - Learn from one of the best in the field

---

This list is constantly evolving as I discover new resources. What are your favorite learning resources? Feel free to reach out and share!

A curated collection of learning resources that shaped my journey in programming, from fundamentals to advanced topics in competitive programming, Android development, and machine learning.

All Posts