Reverse Odd Levels of Binary Tree solution and explanation

```python
def print_hello_world():
    print("Hello, World!")

print_hello_world()
```

```java
public class HelloWorld {
    public static void printHelloWorld() {
        System.out.println("Hello, World!");
    }
    public static void main(String[] args) {
        printHelloWorld();
    }
}
```

```cpp
#include <iostream>

void printHelloWorld() {
    std::cout << "Hello, World!" << std::endl;
}

int main() {
    printHelloWorld();
    return 0;
}
```

```javascript
function printHelloWorld() {
    console.log("Hello, World!");
}

printHelloWorld();
```

```c
#include <stdio.h>

void printHelloWorld() {
    printf("Hello, World!\n");
}

int main() {
    printHelloWorld();
    return 0;
}
```

```csharp
using System;

class HelloWorld {
    static void PrintHelloWorld() {
        Console.WriteLine("Hello, World!");
    }
    static void Main() {
        PrintHelloWorld();
    }
}
```

```python
def find_first_repeated_char(s):
    count = {}
    for ch in s:
        if ch in count:
            return ch
        count[ch] = 1
    return None

str = "programming"
print(f"First repeated character: {find_first_repeated_char(str)}")
```

```java
import java.util.HashMap;

public class FirstRepeatedCharacter {
    public static char firstRepeatedChar(String s) {
        HashMap<Character, Integer> count = new HashMap<>();
        for (char ch : s.toCharArray()) {
            count.put(ch, count.getOrDefault(ch, 0) + 1);
            if (count.get(ch) > 1) return ch;
        }
        return '\0';
    }

    public static void main(String[] args) {
        String str = "programming";
        System.out.println("First repeated character: " + firstRepeatedChar(str));
    }
}
```

```cpp
#include <iostream>
#include <unordered_map>
#include <string>

char findFirstRepeatedChar(const std::string& s) {
    std::unordered_map<char, int> count;
    for (char ch : s) {
        count[ch]++;
        if (count[ch] > 1) return ch;
    }
    return '\0';  // NULL character if no repetitions
}

int main() {
    std::string str = "programming";
    std::cout << "First repeated character: " << findFirstRepeatedChar(str) << std::endl;
    return 0;
}
```

```javascript
function findFirstRepeatedChar(s) {
    const count = {};
    for (const ch of s) {
        if (count[ch]) return ch;
        count[ch] = 1;
    }
    return null;
}

const str = "programming";
console.log(`First repeated character: ${findFirstRepeatedChar(str)}`);
```

```c
#include <stdio.h>

char* findRepeatedCharacter(char* s) {
    int count[256] = {0};
    int i = 0;
    while (s[i] != '\0') {
        count[(int)s[i]]++;
        if (count[(int)s[i]] > 1) {
            return &s[i];
        }
        i++;
    }
    return NULL;
}

int main() {
    char str[] = "programming";
    printf("First repeated character: %c\n", *findRepeatedCharacter(str));
    return 0;
}
```

```csharp
using System;
using System.Collections.Generic;

class Program {
    static char FindFirstRepeatedChar(string s) {
        Dictionary<char, int> count = new Dictionary<char, int>();
        foreach (char ch in s) {
            if (!count.ContainsKey(ch))
                count[ch] = 0;
            count[ch]++;
            if (count[ch] > 1) return ch;
        }
        return '\0';
    }

    static void Main() {
        string str = "programming";
        Console.WriteLine("First repeated character: " + FindFirstRepeatedChar(str));
    }
}
```

/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     val: number
 *     left: TreeNode | null
 *     right: TreeNode | null
 *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
 *         this.val = (val===undefined ? 0 : val)
 *         this.left = (left===undefined ? null : left)
 *         this.right = (right===undefined ? null : right)
 *     }
 * }
 */

function reverseOddLevels(root: TreeNode | null): TreeNode | null {
    const q: TreeNode[] = [root];
    for (let i = 0; q.length > 0; ++i) {
        if (i % 2) {
            for (let l = 0, r = q.length - 1; l < r; ++l, --r) {
                [q[l].val, q[r].val] = [q[r].val, q[l].val];
            }
        }
        const nq: TreeNode[] = [];
        for (const { left, right } of q) {
            if (left) {
                nq.push(left);
                nq.push(right);
            }
        }
        q.splice(0, q.length, ...nq);
    }
    return root;
}

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func reverseOddLevels(root *TreeNode) *TreeNode {
	q := []*TreeNode{root}
	for i := 0; len(q) > 0; i++ {
		t := []*TreeNode{}
		for k := len(q); k > 0; k-- {
			node := q[0]
			q = q[1:]
			if i%2 == 1 {
				t = append(t, node)
			}
			if node.Left != nil {
				q = append(q, node.Left)
				q = append(q, node.Right)
			}
		}
		for l, r := 0, len(t)-1; l < r; l, r = l+1, r-1 {
			t[l].Val, t[r].Val = t[r].Val, t[l].Val
		}
	}
	return root
}

// Definition for a binary tree node.
// #[derive(Debug, PartialEq, Eq)]
// pub struct TreeNode {
//   pub val: i32,
//   pub left: Option<Rc<RefCell<TreeNode>>>,
//   pub right: Option<Rc<RefCell<TreeNode>>>,
// }
//
// impl TreeNode {
//   #[inline]
//   pub fn new(val: i32) -> Self {
//     TreeNode {
//       val,
//       left: None,
//       right: None
//     }
//   }
// }
use std::cell::RefCell;
use std::collections::VecDeque;
use std::rc::Rc;
impl Solution {
    fn create_tree(vals: &Vec<Vec<i32>>, i: usize, j: usize) -> Option<Rc<RefCell<TreeNode>>> {
        if i == vals.len() {
            return None;
        }
        Some(Rc::new(RefCell::new(TreeNode {
            val: vals[i][j],
            left: Self::create_tree(vals, i + 1, j * 2),
            right: Self::create_tree(vals, i + 1, j * 2 + 1),
        })))
    }

    pub fn reverse_odd_levels(
        root: Option<Rc<RefCell<TreeNode>>>,
    ) -> Option<Rc<RefCell<TreeNode>>> {
        let mut queue = VecDeque::new();
        queue.push_back(root);
        let mut d = 0;
        let mut vals = Vec::new();
        while !queue.is_empty() {
            let mut val = Vec::new();
            for _ in 0..queue.len() {
                let mut node = queue.pop_front().unwrap();
                let mut node = node.as_mut().unwrap().borrow_mut();
                val.push(node.val);
                if node.left.is_some() {
                    queue.push_back(node.left.take());
                }
                if node.right.is_some() {
                    queue.push_back(node.right.take());
                }
            }
            if d % 2 == 1 {
                val.reverse();
            }
            vals.push(val);
            d += 1;
        }
        Self::create_tree(&vals, 0, 0)
    }
}